2008-01-11 Thomas Koenig <tkoenig@gcc.gnu.org>

	PR libfortran/34670
	* m4/iparm.m4 (upcase):  New macro (copied from the m4 manual).
	(u_name):  New macro for the upper case name of the intrinsic.
	* m4/iforeach.m4 (name`'rtype_qual`_'atype_code):  Add
	bounds checking and rank check, depending on
	compile_options.bounds_check.
	(`m'name`'rtype_qual`_'atype_code):  Likewise.
	(`s'name`'rtype_qual`_'atype_code):  Likewise.
	* m4/ifunction.m4 (name`'rtype_qual`_'atype_code):  Add
	bounds checking and rank check, depending on
	compile_options.bounds_check.
	(`m'name`'rtype_qual`_'atype_code):  Likewise.
	(`s'name`'rtype_qual`_'atype_code):  Likewise.
	* generated/all_l16.c: Regenerated.
	* generated/all_l4.c: Regenerated.
	* generated/all_l8.c: Regenerated.
	* generated/any_l16.c: Regenerated.
	* generated/any_l4.c: Regenerated.
	* generated/any_l8.c: Regenerated.
	* generated/count_16_l16.c: Regenerated.
	* generated/count_16_l4.c: Regenerated.
	* generated/count_16_l8.c: Regenerated.
	* generated/count_4_l16.c: Regenerated.
	* generated/count_4_l4.c: Regenerated.
	* generated/count_4_l8.c: Regenerated.
	* generated/count_8_l16.c: Regenerated.
	* generated/count_8_l4.c: Regenerated.
	* generated/count_8_l8.c: Regenerated.
	* generated/maxloc0_16_i1.c: Regenerated.
	* generated/maxloc0_16_i16.c: Regenerated.
	* generated/maxloc0_16_i2.c: Regenerated.
	* generated/maxloc0_16_i4.c: Regenerated.
	* generated/maxloc0_16_i8.c: Regenerated.
	* generated/maxloc0_16_r10.c: Regenerated.
	* generated/maxloc0_16_r16.c: Regenerated.
	* generated/maxloc0_16_r4.c: Regenerated.
	* generated/maxloc0_16_r8.c: Regenerated.
	* generated/maxloc0_4_i1.c: Regenerated.
	* generated/maxloc0_4_i16.c: Regenerated.
	* generated/maxloc0_4_i2.c: Regenerated.
	* generated/maxloc0_4_i4.c: Regenerated.
	* generated/maxloc0_4_i8.c: Regenerated.
	* generated/maxloc0_4_r10.c: Regenerated.
	* generated/maxloc0_4_r16.c: Regenerated.
	* generated/maxloc0_4_r4.c: Regenerated.
	* generated/maxloc0_4_r8.c: Regenerated.
	* generated/maxloc0_8_i1.c: Regenerated.
	* generated/maxloc0_8_i16.c: Regenerated.
	* generated/maxloc0_8_i2.c: Regenerated.
	* generated/maxloc0_8_i4.c: Regenerated.
	* generated/maxloc0_8_i8.c: Regenerated.
	* generated/maxloc0_8_r10.c: Regenerated.
	* generated/maxloc0_8_r16.c: Regenerated.
	* generated/maxloc0_8_r4.c: Regenerated.
	* generated/maxloc0_8_r8.c: Regenerated.
	* generated/maxloc1_16_i1.c: Regenerated.
	* generated/maxloc1_16_i16.c: Regenerated.
	* generated/maxloc1_16_i2.c: Regenerated.
	* generated/maxloc1_16_i4.c: Regenerated.
	* generated/maxloc1_16_i8.c: Regenerated.
	* generated/maxloc1_16_r10.c: Regenerated.
	* generated/maxloc1_16_r16.c: Regenerated.
	* generated/maxloc1_16_r4.c: Regenerated.
	* generated/maxloc1_16_r8.c: Regenerated.
	* generated/maxloc1_4_i1.c: Regenerated.
	* generated/maxloc1_4_i16.c: Regenerated.
	* generated/maxloc1_4_i2.c: Regenerated.
	* generated/maxloc1_4_i4.c: Regenerated.
	* generated/maxloc1_4_i8.c: Regenerated.
	* generated/maxloc1_4_r10.c: Regenerated.
	* generated/maxloc1_4_r16.c: Regenerated.
	* generated/maxloc1_4_r4.c: Regenerated.
	* generated/maxloc1_4_r8.c: Regenerated.
	* generated/maxloc1_8_i1.c: Regenerated.
	* generated/maxloc1_8_i16.c: Regenerated.
	* generated/maxloc1_8_i2.c: Regenerated.
	* generated/maxloc1_8_i4.c: Regenerated.
	* generated/maxloc1_8_i8.c: Regenerated.
	* generated/maxloc1_8_r10.c: Regenerated.
	* generated/maxloc1_8_r16.c: Regenerated.
	* generated/maxloc1_8_r4.c: Regenerated.
	* generated/maxloc1_8_r8.c: Regenerated.
	* generated/maxval_i1.c: Regenerated.
	* generated/maxval_i16.c: Regenerated.
	* generated/maxval_i2.c: Regenerated.
	* generated/maxval_i4.c: Regenerated.
	* generated/maxval_i8.c: Regenerated.
	* generated/maxval_r10.c: Regenerated.
	* generated/maxval_r16.c: Regenerated.
	* generated/maxval_r4.c: Regenerated.
	* generated/maxval_r8.c: Regenerated.
	* generated/minloc0_16_i1.c: Regenerated.
	* generated/minloc0_16_i16.c: Regenerated.
	* generated/minloc0_16_i2.c: Regenerated.
	* generated/minloc0_16_i4.c: Regenerated.
	* generated/minloc0_16_i8.c: Regenerated.
	* generated/minloc0_16_r10.c: Regenerated.
	* generated/minloc0_16_r16.c: Regenerated.
	* generated/minloc0_16_r4.c: Regenerated.
	* generated/minloc0_16_r8.c: Regenerated.
	* generated/minloc0_4_i1.c: Regenerated.
	* generated/minloc0_4_i16.c: Regenerated.
	* generated/minloc0_4_i2.c: Regenerated.
	* generated/minloc0_4_i4.c: Regenerated.
	* generated/minloc0_4_i8.c: Regenerated.
	* generated/minloc0_4_r10.c: Regenerated.
	* generated/minloc0_4_r16.c: Regenerated.
	* generated/minloc0_4_r4.c: Regenerated.
	* generated/minloc0_4_r8.c: Regenerated.
	* generated/minloc0_8_i1.c: Regenerated.
	* generated/minloc0_8_i16.c: Regenerated.
	* generated/minloc0_8_i2.c: Regenerated.
	* generated/minloc0_8_i4.c: Regenerated.
	* generated/minloc0_8_i8.c: Regenerated.
	* generated/minloc0_8_r10.c: Regenerated.
	* generated/minloc0_8_r16.c: Regenerated.
	* generated/minloc0_8_r4.c: Regenerated.
	* generated/minloc0_8_r8.c: Regenerated.
	* generated/minloc1_16_i1.c: Regenerated.
	* generated/minloc1_16_i16.c: Regenerated.
	* generated/minloc1_16_i2.c: Regenerated.
	* generated/minloc1_16_i4.c: Regenerated.
	* generated/minloc1_16_i8.c: Regenerated.
	* generated/minloc1_16_r10.c: Regenerated.
	* generated/minloc1_16_r16.c: Regenerated.
	* generated/minloc1_16_r4.c: Regenerated.
	* generated/minloc1_16_r8.c: Regenerated.
	* generated/minloc1_4_i1.c: Regenerated.
	* generated/minloc1_4_i16.c: Regenerated.
	* generated/minloc1_4_i2.c: Regenerated.
	* generated/minloc1_4_i4.c: Regenerated.
	* generated/minloc1_4_i8.c: Regenerated.
	* generated/minloc1_4_r10.c: Regenerated.
	* generated/minloc1_4_r16.c: Regenerated.
	* generated/minloc1_4_r4.c: Regenerated.
	* generated/minloc1_4_r8.c: Regenerated.
	* generated/minloc1_8_i1.c: Regenerated.
	* generated/minloc1_8_i16.c: Regenerated.
	* generated/minloc1_8_i2.c: Regenerated.
	* generated/minloc1_8_i4.c: Regenerated.
	* generated/minloc1_8_i8.c: Regenerated.
	* generated/minloc1_8_r10.c: Regenerated.
	* generated/minloc1_8_r16.c: Regenerated.
	* generated/minloc1_8_r4.c: Regenerated.
	* generated/minloc1_8_r8.c: Regenerated.
	* generated/minval_i1.c: Regenerated.
	* generated/minval_i16.c: Regenerated.
	* generated/minval_i2.c: Regenerated.
	* generated/minval_i4.c: Regenerated.
	* generated/minval_i8.c: Regenerated.
	* generated/minval_r10.c: Regenerated.
	* generated/minval_r16.c: Regenerated.
	* generated/minval_r4.c: Regenerated.
	* generated/minval_r8.c: Regenerated.
	* generated/product_c10.c: Regenerated.
	* generated/product_c16.c: Regenerated.
	* generated/product_c4.c: Regenerated.
	* generated/product_c8.c: Regenerated.
	* generated/product_i1.c: Regenerated.
	* generated/product_i16.c: Regenerated.
	* generated/product_i2.c: Regenerated.
	* generated/product_i4.c: Regenerated.
	* generated/product_i8.c: Regenerated.
	* generated/product_r10.c: Regenerated.
	* generated/product_r16.c: Regenerated.
	* generated/product_r4.c: Regenerated.
	* generated/product_r8.c: Regenerated.
	* generated/sum_c10.c: Regenerated.
	* generated/sum_c16.c: Regenerated.
	* generated/sum_c4.c: Regenerated.
	* generated/sum_c8.c: Regenerated.
	* generated/sum_i1.c: Regenerated.
	* generated/sum_i16.c: Regenerated.
	* generated/sum_i2.c: Regenerated.
	* generated/sum_i4.c: Regenerated.
	* generated/sum_i8.c: Regenerated.
	* generated/sum_r10.c: Regenerated.
	* generated/sum_r16.c: Regenerated.
	* generated/sum_r4.c: Regenerated.
	* generated/sum_r8.c: Regenerated.

2008-01-11  Thomas Koenig  <tkoenig@gcc.gnu.org>

	PR libfortran/34670
	* all_bounds_1.f90: New test case.
	* maxloc_bounds_1.f90: New test case.
	* maxloc_bounds_2.f90: New test case.
	* maxloc_bounds_3.f90: New test case.
	* maxloc_bounds_4.f90: New test case.
	* maxloc_bounds_5.f90: New test case.
	* maxloc_bounds_6.f90: New test case.
	* maxloc_bounds_7.f90: New test case.
	* maxloc_bounds_8.f90: New test case.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@131473 138bc75d-0d04-0410-961f-82ee72b054a4

167 files changed, 9665 insertions, 1457 deletions

diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c
index 1179f9cf971..2cc81ce423a 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -115,7 +115,25 @@ all_l16 (gfc_array_l16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " ALL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " ALL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c
index 11b9b9fe8ac..12f9efb2b91 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -115,7 +115,25 @@ all_l4 (gfc_array_l4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " ALL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " ALL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c
index 93d00c274bb..c9fa80935ae 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -115,7 +115,25 @@ all_l8 (gfc_array_l8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " ALL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " ALL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c
index 1ca5584b25d..1ba59edbadd 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -115,7 +115,25 @@ any_l16 (gfc_array_l16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " ANY intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " ANY intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c
index b17d2731043..83116ebe9ca 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -115,7 +115,25 @@ any_l4 (gfc_array_l4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " ANY intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " ANY intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c
index 6c50befa85e..a85e6e89ca0 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -115,7 +115,25 @@ any_l8 (gfc_array_l8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " ANY intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " ANY intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_16_l16.c b/libgfortran/generated/count_16_l16.c
index cc9b4702e82..351eb8a1e65 100644
--- a/libgfortran/generated/count_16_l16.c
+++ b/libgfortran/generated/count_16_l16.c
@@ -115,7 +115,25 @@ count_16_l16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_16_l4.c b/libgfortran/generated/count_16_l4.c
index 72d61aeabc2..9f849d8b725 100644
--- a/libgfortran/generated/count_16_l4.c
+++ b/libgfortran/generated/count_16_l4.c
@@ -115,7 +115,25 @@ count_16_l4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_16_l8.c b/libgfortran/generated/count_16_l8.c
index 9275f7e2265..90659da0a17 100644
--- a/libgfortran/generated/count_16_l8.c
+++ b/libgfortran/generated/count_16_l8.c
@@ -115,7 +115,25 @@ count_16_l8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_4_l16.c b/libgfortran/generated/count_4_l16.c
index d111855c942..c3b3daad85a 100644
--- a/libgfortran/generated/count_4_l16.c
+++ b/libgfortran/generated/count_4_l16.c
@@ -115,7 +115,25 @@ count_4_l16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_4_l4.c b/libgfortran/generated/count_4_l4.c
index de1f386d82c..3bfcf179c75 100644
--- a/libgfortran/generated/count_4_l4.c
+++ b/libgfortran/generated/count_4_l4.c
@@ -115,7 +115,25 @@ count_4_l4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_4_l8.c b/libgfortran/generated/count_4_l8.c
index e3a80a409c5..7debda799bb 100644
--- a/libgfortran/generated/count_4_l8.c
+++ b/libgfortran/generated/count_4_l8.c
@@ -115,7 +115,25 @@ count_4_l8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_8_l16.c b/libgfortran/generated/count_8_l16.c
index 9f3d2458e8e..815b79ab65c 100644
--- a/libgfortran/generated/count_8_l16.c
+++ b/libgfortran/generated/count_8_l16.c
@@ -115,7 +115,25 @@ count_8_l16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_8_l4.c b/libgfortran/generated/count_8_l4.c
index adbf30932ac..84401ded1e1 100644
--- a/libgfortran/generated/count_8_l4.c
+++ b/libgfortran/generated/count_8_l4.c
@@ -115,7 +115,25 @@ count_8_l4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/count_8_l8.c b/libgfortran/generated/count_8_l8.c
index 927c7ae8bd5..fd26280a550 100644
--- a/libgfortran/generated/count_8_l8.c
+++ b/libgfortran/generated/count_8_l8.c
@@ -115,7 +115,25 @@ count_8_l8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " COUNT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " COUNT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index dd05af10a84..3cd6554a346 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -69,11 +69,22 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index 2a68c549694..9bfec043013 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -69,11 +69,22 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index 093170ac8c4..b57e78f9274 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -69,11 +69,22 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index d166829a2db..2e123b6d295 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -69,11 +69,22 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index e7cc15236e2..cd141a69222 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -69,11 +69,22 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index 5bb8ef1f851..8426d3af81e 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -69,11 +69,22 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 0b306290aae..3244452c601 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -69,11 +69,22 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 7a0b15613bc..8057063339c 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -69,11 +69,22 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index e29f80cb03e..6c12815a0a1 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -69,11 +69,22 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 673b7cfa7ee..42c865a6e29 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -69,11 +69,22 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index 533b6824ec3..938ceba6974 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -69,11 +69,22 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index 43b6e15afab..809d93821dc 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -69,11 +69,22 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index 57241ff01aa..5108cbe1366 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -69,11 +69,22 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index c7f7f360ca9..987b424d7e1 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -69,11 +69,22 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index 694b621cafa..b3101bd6ac8 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -69,11 +69,22 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index e3c093a15a2..9b1e5274a3f 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -69,11 +69,22 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index a634f31532e..bf4692c26f0 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -69,11 +69,22 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index 737de141b23..774a6734c2d 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -69,11 +69,22 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index c1aa00e6cb6..38890b70dcf 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -69,11 +69,22 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index 2966228a996..be99a8ca0b1 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -69,11 +69,22 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index 54555a94510..02a5f645e8e 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -69,11 +69,22 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index 3a22cb02e95..dca0b768861 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -69,11 +69,22 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index a756905244d..d11ba2677f2 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -69,11 +69,22 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 706bd531fda..898f1f57673 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -69,11 +69,22 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index b849d5067cb..6dec78a49f9 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -69,11 +69,22 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 745f295d7b5..345dbe1a9d1 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -69,11 +69,22 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index 4441887f698..bf7020e1a10 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -69,11 +69,22 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MAXLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MAXLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 942d92e6bbc..477eb704a86 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -116,7 +116,25 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index 0eca9167824..e4a2c1b361b 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -116,7 +116,25 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index c4fa7b339fe..f5d7b587aed 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -116,7 +116,25 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 7747f80de71..1fbda541ae3 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -116,7 +116,25 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index 7fe4b6c6733..59be84cd62c 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -116,7 +116,25 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index 8410240c253..3a8c8b7a376 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -116,7 +116,25 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 92543f8adc8..60b97249ada 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -116,7 +116,25 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index be979ad6cb0..a36a9d1133c 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -116,7 +116,25 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 3af2124b137..9c659c0d3a6 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -116,7 +116,25 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index b588a86a4c7..1d9132888cd 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -116,7 +116,25 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index 646cb48f438..92a08bef0bd 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -116,7 +116,25 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index 8bc84f80c3d..b03d90a9592 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -116,7 +116,25 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index 51b62618362..dc90ec29d8d 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -116,7 +116,25 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index 0c52075aaf3..78da94438cd 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -116,7 +116,25 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 8354f7184ac..1c83f62f728 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -116,7 +116,25 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index 6ee0c0d8218..a31d0ac5afa 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -116,7 +116,25 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index c045ab5f5cb..49d9cd5463b 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -116,7 +116,25 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index baae300a03b..822680a4941 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -116,7 +116,25 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index f09e54a6cc1..5c607532dbc 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -116,7 +116,25 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index 8a8e9c60dd6..feefc084883 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -116,7 +116,25 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index 5defc330ea5..8e4868d7308 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -116,7 +116,25 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index 0bd38f1b25c..cb9d14d8d1d 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -116,7 +116,25 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 56ed65f05fb..8b8f2a96914 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -116,7 +116,25 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index 0270184df35..6aa6ec1941c 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -116,7 +116,25 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index 93b0c722ea2..59db207cfc0 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -116,7 +116,25 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 3c9104e2c54..3640a5dea96 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -116,7 +116,25 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index abb27679bfb..93c7c78aec7 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -116,7 +116,25 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 163e20044d8..5158e2a60cc 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -115,7 +115,25 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index f48efb86143..a10c8fa57c9 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -115,7 +115,25 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 9515b991bcf..3819e0e0101 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -115,7 +115,25 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 95ccb1ff0d9..1076336a02f 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -115,7 +115,25 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index 7d361a8a153..f527983097c 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -115,7 +115,25 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index 3a423ff2008..fd775c0e4d5 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -115,7 +115,25 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index 7ea30a075c7..671ce1499f9 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -115,7 +115,25 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 75d6a06727c..674142274e9 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -115,7 +115,25 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 54e4209d882..136ef20794c 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -115,7 +115,25 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MAXVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MAXVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MAXVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MAXVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index bb0fdd952dc..9529997a374 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -69,11 +69,22 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 428340ca9a7..667bfd8a349 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -69,11 +69,22 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index 523b980fb8f..a5c499410bd 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -69,11 +69,22 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 67062d3d995..7c9292cddb3 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -69,11 +69,22 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index 2b62a673804..022e49c9707 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -69,11 +69,22 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index 1329d30adaa..a99c5307afc 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -69,11 +69,22 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index a50b0289f29..2b2dcaacb23 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -69,11 +69,22 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index d33368f8bad..f265ae47561 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -69,11 +69,22 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index 37e0b581c71..59429f22ee9 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -69,11 +69,22 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index 18ae10b3353..24463ead318 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -69,11 +69,22 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index 7ca79b16b7a..ddcbc60eab9 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -69,11 +69,22 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index c6789d990e6..60b2c3fcb57 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -69,11 +69,22 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 13524f1e84b..6431f38ba59 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -69,11 +69,22 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 9d80fd35f9b..6ffeac577fc 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -69,11 +69,22 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index 58f1805d448..e4f10024c50 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -69,11 +69,22 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index 1a1bc031c5d..0f9fb980467 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -69,11 +69,22 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index 3c312c6921d..14c63b35e13 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -69,11 +69,22 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index ad3b534b972..168d0ad2621 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -69,11 +69,22 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index 4aa5f18c282..6dcafbae05d 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -69,11 +69,22 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index 88adc44a861..f2afae1e643 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -69,11 +69,22 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index c7e5f1352de..d0dd1374427 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -69,11 +69,22 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 401349e3ea5..a4c921acfe3 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -69,11 +69,22 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index bc3abcaf2ec..26aa9476cf4 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -69,11 +69,22 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index 90f652e25b3..b1705ebc5fd 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -69,11 +69,22 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index 67d5e0c8e02..84b95baa6a5 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -69,11 +69,22 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index a542e9dea49..d7b8d547ece 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -69,11 +69,22 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 98d6a8ef865..6ac0bfe1b00 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -69,11 +69,22 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	}
     }
 
   dstride = retarray->dim[0].stride;
@@ -182,11 +193,40 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
-
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank, mask_rank;
+	  index_type ret_extent;
+	  int n;
+	  index_type array_extent, mask_extent;
+
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	  if (ret_extent != rank)
+	    runtime_error ("Incorrect extent in return value of"
+			   " MINLOC intrnisic: is %ld, should be %d",
+			   (long int) ret_extent, rank);
+	
+	  mask_rank = GFC_DESCRIPTOR_RANK (mask);
+	  if (rank != mask_rank)
+	    runtime_error ("rank of MASK argument in MINLOC intrnisic"
+	                   "should be %d, is %d", rank, mask_rank);
+
+	  for (n=0; n<rank; n++)
+	    {
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
@@ -312,11 +352,20 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
+
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
     }
 
   dstride = retarray->dim[0].stride;
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index c029050fcf8..c1baf547b4b 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -116,7 +116,25 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index 88f7e0c64cb..db992cb4a7c 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -116,7 +116,25 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index 2268b2ebfdd..523a4affff4 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -116,7 +116,25 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index e4a60ac0e56..e8d5fc397c6 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -116,7 +116,25 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index b8222989c8c..8c3e4e48242 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -116,7 +116,25 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index 982a048a7d9..7aa89a947cc 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -116,7 +116,25 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index 1e43b24aa14..5b814451d60 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -116,7 +116,25 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index 7f93dd0b956..b3c61552ffe 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -116,7 +116,25 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index 96eaa9c139b..0a4b1b50777 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -116,7 +116,25 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index deb70a155d9..9cebebe10a0 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -116,7 +116,25 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index 8252d1874d7..a984a153d38 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -116,7 +116,25 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index 27768fb6134..685f9793b73 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -116,7 +116,25 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index 11579c367f9..f44a631d352 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -116,7 +116,25 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index cf54b1a0d40..f6858c02820 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -116,7 +116,25 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 990d7ea43c8..8e359fe1519 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -116,7 +116,25 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index a380df29276..11cb9c8f962 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -116,7 +116,25 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 62e0b2c67d9..31aa1f7a621 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -116,7 +116,25 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index 16b210ffb45..a7a56b67f89 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -116,7 +116,25 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index e50acae5a41..1fae32b3fb6 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -116,7 +116,25 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index ed20ec71bc3..0d31c944b85 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -116,7 +116,25 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index 743c584ba7c..88655757ddc 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -116,7 +116,25 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 1d64d2cf021..31ee2385b36 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -116,7 +116,25 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index d658451d9fe..13577aba741 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -116,7 +116,25 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index 1b6888ef428..726aa1c8937 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -116,7 +116,25 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index e59b187e70f..aaf9797856d 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -116,7 +116,25 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index d7d69e59684..6b0bcec629c 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -116,7 +116,25 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 03f88bd77b0..8a8d266393d 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -116,7 +116,25 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINLOC intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -293,7 +311,35 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINLOC intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINLOC intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -406,13 +452,21 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINLOC intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index 37e0b16de2a..ef31ba0c8d8 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -115,7 +115,25 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index fdac2877e17..8d7bf50c4ae 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -115,7 +115,25 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index 593497393cf..c3d63f6482b 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -115,7 +115,25 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index 660f0e73780..48ea446db9c 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -115,7 +115,25 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index d7d4c09cf2b..cd2100a05ac 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -115,7 +115,25 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index 4769f0cf38f..10d0302d4ee 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -115,7 +115,25 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index 6754072e150..da6e7963a3a 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -115,7 +115,25 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index ab7d909fbdc..745889a8131 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -115,7 +115,25 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 53c7e448805..1b0fec0174a 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -115,7 +115,25 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " MINVAL intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -287,7 +305,35 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in MINVAL intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " MINVAL intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -395,13 +441,21 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in MINVAL intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index 34d4e94806e..701835f9a43 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -115,7 +115,25 @@ product_c10 (gfc_array_c10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index e95dbac079a..1d58a768756 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -115,7 +115,25 @@ product_c16 (gfc_array_c16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index 6c17247c7ac..3754fcb5cae 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -115,7 +115,25 @@ product_c4 (gfc_array_c4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index 5d26d3e7cf1..6312451b794 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -115,7 +115,25 @@ product_c8 (gfc_array_c8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index 9926bdc6af8..7003129a4f7 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -115,7 +115,25 @@ product_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index f667a6578ce..3c448082195 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -115,7 +115,25 @@ product_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index a862404146b..ca57d29dc20 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -115,7 +115,25 @@ product_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index 5a8a337bc33..d31eb6e1598 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -115,7 +115,25 @@ product_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index 29c15838fde..8867aaea2fd 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -115,7 +115,25 @@ product_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index 63ef48af791..235b8a664dd 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -115,7 +115,25 @@ product_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index bb232c5261d..2f837e303f1 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -115,7 +115,25 @@ product_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 6899f344653..4e6c3d178ef 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -115,7 +115,25 @@ product_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index e2d613f3063..849d404869d 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -115,7 +115,25 @@ product_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " PRODUCT intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in PRODUCT intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " PRODUCT intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in PRODUCT intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index 46106c95edb..f3da3849808 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -115,7 +115,25 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index 53040b4a553..df79daf313a 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -115,7 +115,25 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index 89cc92b8304..9ef9e8399f7 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -115,7 +115,25 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index f78105d9bd6..a7f7392e747 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -115,7 +115,25 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index f20bd871168..8740fb79b5e 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -115,7 +115,25 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index 19c4a71cf8a..6500d178fa4 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -115,7 +115,25 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index 984b23be1f2..10202c35ac8 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -115,7 +115,25 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 93569f49df2..4d0e8a4a963 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -115,7 +115,25 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index 67f303c163b..8b280a81e0d 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -115,7 +115,25 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index aa260f05c67..0fd8775f93c 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -115,7 +115,25 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index 286b9869eba..8903b64d8bc 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -115,7 +115,25 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index d9ecfd44726..1d3f2d09008 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -115,7 +115,25 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;
 
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index ffa7b878230..d049876d5f2 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -115,7 +115,25 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in"
+		       " SUM intrinsic: is %d, should be %d",
+		       GFC_DESCRIPTOR_RANK (retarray), rank);
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -286,7 +304,35 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
   else
     {
       if (rank != GFC_DESCRIPTOR_RANK (retarray))
-	runtime_error ("rank of return array incorrect");
+	runtime_error ("rank of return array incorrect in SUM intrinsic");
+
+      if (compile_options.bounds_check)
+	{
+	  for (n=0; n < rank; n++)
+	    {
+	      index_type ret_extent;
+
+	      ret_extent = retarray->dim[n].ubound + 1
+		- retarray->dim[n].lbound;
+	      if (extent[n] != ret_extent)
+		runtime_error ("Incorrect extent in return value of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) ret_extent, (long int) extent[n]);
+	    }
+          for (n=0; n<= rank; n++)
+            {
+              index_type mask_extent, array_extent;
+
+	      array_extent = array->dim[n].ubound + 1 - array->dim[n].lbound;
+	      mask_extent = mask->dim[n].ubound + 1 - mask->dim[n].lbound;
+	      if (array_extent != mask_extent)
+		runtime_error ("Incorrect extent in MASK argument of"
+			       " SUM intrinsic in dimension %d:"
+			       " is %ld, should be %ld", n + 1,
+			       (long int) mask_extent, (long int) array_extent);
+	    }
+	}
     }
 
   for (n = 0; n < rank; n++)
@@ -394,13 +440,21 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
     }
   else
     {
-      if (GFC_DESCRIPTOR_RANK (retarray) != 1)
-	runtime_error ("rank of return array does not equal 1");
+      if (compile_options.bounds_check)
+	{
+	  int ret_rank;
+	  index_type ret_extent;
 
-      if (retarray->dim[0].ubound + 1 - retarray->dim[0].lbound != rank)
-        runtime_error ("dimension of return array incorrect");
-    }
+	  ret_rank = GFC_DESCRIPTOR_RANK (retarray);
+	  if (ret_rank != 1)
+	    runtime_error ("rank of return array in SUM intrinsic"
+			   " should be 1, is %d", ret_rank);
 
+	  ret_extent = retarray->dim[0].ubound + 1 - retarray->dim[0].lbound;
+	    if (ret_extent != rank)
+	      runtime_error ("dimension of return array incorrect");
+	}
+    }
     dstride = retarray->dim[0].stride;
     dest = retarray->data;