gdb: remove TYPE_VECTOR

gdb/ChangeLog:

	* gdbtypes.h (TYPE_VECTOR): Remove, replace all
	uses with type::is_vector.

Change-Id: I1ac28755af44b1585c190553f9961288c8fb9137

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b28de5b6ad01f24684e414abc483cc077d10dc6a..b8f2361b9052dc458e6f70d5ce70153f296f46a3 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2020-09-14  Simon Marchi  <simon.marchi@efficios.com>
+
+       * gdbtypes.h (TYPE_VECTOR): Remove, replace all
+       uses with type::is_vector.
+
 2020-09-14  Simon Marchi  <simon.marchi@efficios.com>
 
        * gdbtypes.h (struct type) <is_vector, set_is_vector>: New methods.

diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c
index 61e8e57552cac13e4981612463788a2e26bc89ca..a2547d12dc6b784a1d2db34c05cdf96f83917959 100644 (file)
--- a/gdb/aarch64-tdep.c
+++ b/gdb/aarch64-tdep.c
@@ -1393,7 +1393,7 @@ static ULONGEST
 aarch64_type_align (gdbarch *gdbarch, struct type *t)
 {
   t = check_typedef (t);
-  if (t->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (t))
+  if (t->code () == TYPE_CODE_ARRAY && t->is_vector ())
     {
       /* Use the natural alignment for vector types (the same for
         scalar type), but the maximum alignment is 128-bit.  */
@@ -1453,7 +1453,7 @@ aapcs_is_vfp_call_or_return_candidate_1 (struct type *type,
 
     case TYPE_CODE_ARRAY:
       {
-       if (TYPE_VECTOR (type))
+       if (type->is_vector ())
          {
            if (TYPE_LENGTH (type) != 8 && TYPE_LENGTH (type) != 16)
              return -1;
@@ -1760,7 +1760,7 @@ pass_in_v_vfp_candidate (struct gdbarch *gdbarch, struct regcache *regcache,
       }
 
     case TYPE_CODE_ARRAY:
-      if (TYPE_VECTOR (arg_type))
+      if (arg_type->is_vector ())
        return pass_in_v (gdbarch, regcache, info, TYPE_LENGTH (arg_type),
                          value_contents (arg));
       /* fall through.  */

diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index ecf65f24a19578373a482e80ad1ccce812781381..5470332e1c10113a36d33a0af86d9bcef3201200 100644 (file)
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -3417,7 +3417,7 @@ static ULONGEST
 arm_type_align (gdbarch *gdbarch, struct type *t)
 {
   t = check_typedef (t);
-  if (t->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (t))
+  if (t->code () == TYPE_CODE_ARRAY && t->is_vector ())
     {
       /* Use the natural alignment for vector types (the same for
         scalar type), but the maximum alignment is 64-bit.  */
@@ -3562,7 +3562,7 @@ arm_vfp_cprc_sub_candidate (struct type *t,
 
     case TYPE_CODE_ARRAY:
       {
-       if (TYPE_VECTOR (t))
+       if (t->is_vector ())
          {
            /* A 64-bit or 128-bit containerized vector type are VFP
               CPRCs.  */
@@ -8017,7 +8017,7 @@ arm_return_in_memory (struct gdbarch *gdbarch, struct type *type)
       && TYPE_CODE_ARRAY != code && TYPE_CODE_COMPLEX != code)
     return 0;
 
-  if (TYPE_CODE_ARRAY == code && TYPE_VECTOR (type))
+  if (TYPE_CODE_ARRAY == code && type->is_vector ())
     {
       /* Vector values should be returned using ARM registers if they
         are not over 16 bytes.  */

diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index 0c2268f8d0aebbb92d87e94d15eb6d25ccc68be7..b642c881787e9d7da5229ffdaca1545885bcdece 100644 (file)
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -133,7 +133,7 @@ c_print_type_1 (struct type *type,
              && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
                  || code == TYPE_CODE_METHOD
                  || (code == TYPE_CODE_ARRAY
-                     && !TYPE_VECTOR (type))
+                     && !type->is_vector ())
                  || code == TYPE_CODE_MEMBERPTR
                  || code == TYPE_CODE_METHODPTR
                  || TYPE_IS_REFERENCE (type))))
@@ -772,7 +772,7 @@ c_type_print_varspec_suffix (struct type *type,
     case TYPE_CODE_ARRAY:
       {
        LONGEST low_bound, high_bound;
-       int is_vector = TYPE_VECTOR (type);
+       int is_vector = type->is_vector ();
 
        if (passed_a_ptr)
          fprintf_filtered (stream, ")");

diff --git a/gdb/compile/compile-c-types.c b/gdb/compile/compile-c-types.c
index 03536c0ca333c3d3095fa8c456899168b02bea1d..6d9bb37b17ce92678b7eae04a046690a56c0f58a 100644 (file)
--- a/gdb/compile/compile-c-types.c
+++ b/gdb/compile/compile-c-types.c
@@ -56,7 +56,7 @@ convert_array (compile_c_instance *context, struct type *type)
     {
       gcc_type result;
 
-      if (TYPE_VECTOR (type))
+      if (type->is_vector ())
        return context->plugin ().error (_("variably-sized vector type"
                                           " is not supported"));
 
@@ -78,7 +78,7 @@ convert_array (compile_c_instance *context, struct type *type)
          count = high_bound + 1;
        }
 
-      if (TYPE_VECTOR (type))
+      if (type->is_vector ())
        return context->plugin ().build_vector_type (element_type, count);
       return context->plugin ().build_array_type (element_type, count);
     }

diff --git a/gdb/compile/compile-cplus-types.c b/gdb/compile/compile-cplus-types.c
index 8270defa17ce02c3ab9da71d3df85a09f641a775..bb4b267e9af25eeefd6097fe66ee837318f9e017 100644 (file)
--- a/gdb/compile/compile-cplus-types.c
+++ b/gdb/compile/compile-cplus-types.c
@@ -475,7 +475,7 @@ compile_cplus_convert_array (compile_cplus_instance *instance,
   if (range->bounds ()->high.kind () == PROP_LOCEXPR
       || range->bounds ()->high.kind () == PROP_LOCLIST)
     {
-      if (TYPE_VECTOR (type))
+      if (type->is_vector ())
        {
          const char *s = _("variably-sized vector type is not supported");
 
@@ -499,7 +499,7 @@ compile_cplus_convert_array (compile_cplus_instance *instance,
          count = high_bound + 1;
        }
 
-      if (TYPE_VECTOR (type))
+      if (type->is_vector ())
        return instance->plugin ().build_vector_type (element_type, count);
 
       return instance->plugin ().build_array_type (element_type, count);

diff --git a/gdb/eval.c b/gdb/eval.c
index d87b8dae110aee34d435280710eb65d851a1fdad..2d27198162636ebf69ac7b7f94c7c680a9965057 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -622,7 +622,7 @@ ptrmath_type_p (const struct language_defn *lang, struct type *type)
       return 1;
 
     case TYPE_CODE_ARRAY:
-      return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
+      return type->is_vector () ? 0 : lang->c_style_arrays;
 
     default:
       return 0;
@@ -3137,7 +3137,7 @@ evaluate_subexp_with_coercion (struct expression *exp,
       var = exp->elts[pc + 2].symbol;
       type = check_typedef (SYMBOL_TYPE (var));
       if (type->code () == TYPE_CODE_ARRAY
-         && !TYPE_VECTOR (type)
+         && !type->is_vector ()
          && CAST_IS_CONVERSION (exp->language_defn))
        {
          (*pos) += 4;

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index d8229309dc8ad6a4620142a38e18162cc3219720..89f428faf21d26e3e8298532012d4522f58fd6a1 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -3993,7 +3993,7 @@ check_types_equal (struct type *type1, struct type *type2,
       || type1->has_no_signedness () != type2->has_no_signedness ()
       || TYPE_ENDIANITY_NOT_DEFAULT (type1) != TYPE_ENDIANITY_NOT_DEFAULT (type2)
       || type1->has_varargs () != type2->has_varargs ()
-      || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
+      || type1->is_vector () != type2->is_vector ()
       || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
       || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
       || type1->num_fields () != type2->num_fields ())
@@ -5095,7 +5095,7 @@ recursive_dump_type (struct type *type, int spaces)
   /* This is used for things like AltiVec registers on ppc.  Gcc emits
      an attribute for the array type, which tells whether or not we
      have a vector, instead of a regular array.  */
-  if (TYPE_VECTOR (type))
+  if (type->is_vector ())
     {
       puts_filtered (" TYPE_VECTOR");
     }

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 760d536dd041d494af252633e7fbcc29b5a073ad..4d567e42ab7d12530c830f934739e048c4ee6b7c 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -216,11 +216,6 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags);
 
 #define TYPE_ENDIANITY_NOT_DEFAULT(t) (TYPE_MAIN_TYPE (t)->flag_endianity_not_default)
 
-/* * Identify a vector type.  Gcc is handling this by adding an extra
-   attribute to the array type.  We slurp that in as a new flag of a
-   type.  This is used only in dwarf2read.c.  */
-#define TYPE_VECTOR(t)         ((t)->is_vector ())
-
 /* * The debugging formats (especially STABS) do not contain enough
    information to represent all Ada types---especially those whose
    size depends on dynamic quantities.  Therefore, the GNAT Ada
@@ -1116,6 +1111,10 @@ struct type
     this->main_type->m_flag_varargs = has_varargs;
   }
 
+  /* Identify a vector type.  Gcc is handling this by adding an extra
+     attribute to the array type.  We slurp that in as a new flag of a
+     type.  This is used only in dwarf2read.c.  */
+
   bool is_vector () const
   {
     return this->main_type->m_flag_vector;

diff --git a/gdb/i386-darwin-tdep.c b/gdb/i386-darwin-tdep.c
index 88f5757b98bee70dd88040889e92420da03813d3..82b28af62b3ead2953c138d8e05b8baa3755aa9d 100644 (file)
--- a/gdb/i386-darwin-tdep.c
+++ b/gdb/i386-darwin-tdep.c
@@ -109,7 +109,7 @@ darwin_dwarf_signal_frame_p (struct gdbarch *gdbarch,
 static int
 i386_m128_p (struct type *type)
 {
-  return (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+  return (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
           && TYPE_LENGTH (type) == 16);
 }
 
@@ -124,7 +124,7 @@ i386_darwin_arg_type_alignment (struct type *type)
          aligned to 8-byte boundaries.
      7.  [...]  The caller aligns 128-bit vectors in the parameter area to
          16-byte boundaries.  */
-  if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     return TYPE_LENGTH (type);
   /* 4.  The caller places all the fields of structures (or unions) with no
          vector elements in the parameter area.  These structures are 4-byte

diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 98aaa1408583e5987cf74b2abd119eb27d2f03f3..64e42dcbfe62b80c2929de1b788317c232c29e8f 100644 (file)
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -2636,7 +2636,7 @@ i386_16_byte_align_p (struct type *type)
 {
   type = check_typedef (type);
   if ((type->code () == TYPE_CODE_DECFLOAT
-       || (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))
+       || (type->code () == TYPE_CODE_ARRAY && type->is_vector ()))
       && TYPE_LENGTH (type) == 16)
     return 1;
   if (type->code () == TYPE_CODE_ARRAY)

diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index 5d68f7fb4ffa0e2a24a947e734ce42f016cb8417..6abf8336954c115499b9e985d29574a49adba736 100644 (file)
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -329,7 +329,7 @@ ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
   int raw_p;
   if (group == all_reggroup)
     return 1;
-  vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
+  vector_p = register_type (gdbarch, regnum)->is_vector ();
   float_p = register_type (gdbarch, regnum)->code () == TYPE_CODE_FLT;
   raw_p = regnum < NUM_IA64_RAW_REGS;
   if (group == float_reggroup)

diff --git a/gdb/infcall.c b/gdb/infcall.c
index a158cb5d085c774fb019a5f9b9b73d65f26f0f68..9539d38142886873dcf0d4ff75f600001db3d1a6 100644 (file)
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -220,7 +220,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
          they are vectors, in which case we want to leave them alone,
          because they are passed by value.  */
       if (current_language->c_style_arrays)
-       if (!TYPE_VECTOR (type))
+       if (!type->is_vector ())
          type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
       break;
     case TYPE_CODE_UNDEF:

diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index cfc3169992544597a4e3b9eace310e431e5a6a07..6f20b7d1eed2d5d9f64638e10af5dc957ee1e4e4 100644 (file)
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -2134,7 +2134,7 @@ default_print_one_register_info (struct ui_file *file,
       common_val_print (val, &format_stream, 0, &opts, current_language);
       /* If not a vector register, print it also according to its
         natural format.  */
-      if (print_raw_format && TYPE_VECTOR (regtype) == 0)
+      if (print_raw_format && regtype->is_vector () == 0)
        {
          pad_to_column (format_stream, value_column_2);
          get_user_print_options (&opts);

diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index b55bfbaa4c8dd65aa499a9210df1509c63ea2e2d..9e2a9cba529c9d8ec18fed0bb67f363af94fb701 100644 (file)
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -686,7 +686,7 @@ mips_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
   int pseudo = regnum / gdbarch_num_regs (gdbarch);
   if (reggroup == all_reggroup)
     return pseudo;
-  vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
+  vector_p = register_type (gdbarch, regnum)->is_vector ();
   float_p = register_type (gdbarch, regnum)->code () == TYPE_CODE_FLT;
   /* FIXME: cagney/2003-04-13: Can't yet use gdbarch_num_regs
      (gdbarch), as not all architectures are multi-arch.  */

diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 9b9ce183293120d949e4d72ef53386424d2b08d4..2d5ae17c36d4551eaaed1926fb31823bf8ee98e8 100644 (file)
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -96,7 +96,7 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
     {
       LONGEST lowb, highb;
 
-      if (types[i]->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
+      if (types[i]->code () == TYPE_CODE_ARRAY && types[i]->is_vector ()
          && get_array_bounds (types[i], &lowb, &highb)
          && TYPE_TARGET_TYPE (types[i])->code () == code
          && TYPE_TARGET_TYPE (types[i])->is_unsigned () == flag_unsigned
@@ -497,7 +497,7 @@ opencl_logical_not (struct expression *exp, struct value *arg)
   struct type *rettype;
   struct value *ret;
 
-  if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
       LONGEST lowb, highb;
@@ -586,8 +586,8 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
   type1 = check_typedef (value_type (val1));
   type2 = check_typedef (value_type (val2));
 
-  t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
-  t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
+  t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ());
+  t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ());
 
   if (!t1_is_vec || !t2_is_vec)
     error (_("Vector operations are not supported on scalar types"));
@@ -658,7 +658,7 @@ opencl_value_cast (struct type *type, struct value *arg)
                || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
                || code2 == TYPE_CODE_RANGE);
 
-      if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (to_type) && scalar)
+      if (code1 == TYPE_CODE_ARRAY && to_type->is_vector () && scalar)
        {
          struct type *eltype;
 
@@ -688,9 +688,9 @@ opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2,
   struct type *type1 = check_typedef (value_type (arg1));
   struct type *type2 = check_typedef (value_type (arg2));
   int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type1));
+                  && type1->is_vector ());
   int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type2));
+                  && type2->is_vector ());
 
   if (!t1_is_vec && !t2_is_vec)
     {
@@ -831,8 +831,8 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
          type1 = check_typedef (value_type (arg1));
          type2 = check_typedef (value_type (arg2));
 
-         if ((type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
-             || (type2->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
+         if ((type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
+             || (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ()))
            {
              arg2 = evaluate_subexp (nullptr, exp, pos, noside);
 
@@ -867,7 +867,7 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
       (*pos)++;
       arg1 = evaluate_subexp (nullptr, exp, pos, noside);
       type1 = check_typedef (value_type (arg1));
-      if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+      if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
        {
          struct value *arg3, *tmp, *ret;
          struct type *eltype2, *type3, *eltype3;
@@ -879,9 +879,9 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
          type2 = check_typedef (value_type (arg2));
          type3 = check_typedef (value_type (arg3));
          t2_is_vec
-           = type2->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
+           = type2->code () == TYPE_CODE_ARRAY && type2->is_vector ();
          t3_is_vec
-           = type3->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
+           = type3->code () == TYPE_CODE_ARRAY && type3->is_vector ();
 
          /* Widen the scalar operand to a vector if necessary.  */
          if (t2_is_vec || !t3_is_vec)
@@ -970,7 +970,7 @@ Cannot perform conditional operation on vectors with different sizes"));
            return value_from_longest (builtin_type (exp->gdbarch)->
                                       builtin_int, 1);
          }
-       else if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+       else if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
          {
            return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
                                         noside);
@@ -1062,7 +1062,7 @@ public:
     if (show > 0)
       {
        type = check_typedef (type);
-       if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+       if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
            && type->name () != NULL)
          show = 0;
       }

diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index 4c4bdacf4d1f917709fd3baf690c3371cf3fc0d3..91b206681250bc1d7ee5552a386c508f6c01205a 100644 (file)
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -253,7 +253,7 @@ ppc_linux_return_value (struct gdbarch *gdbarch, struct value *function,
   if ((valtype->code () == TYPE_CODE_STRUCT
        || valtype->code () == TYPE_CODE_UNION)
       && !((TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 8)
-          && TYPE_VECTOR (valtype)))
+          && valtype->is_vector ()))
     return RETURN_VALUE_STRUCT_CONVENTION;
   else
     return ppc_sysv_abi_return_value (gdbarch, function, valtype, regcache,

diff --git a/gdb/ppc-nbsd-tdep.c b/gdb/ppc-nbsd-tdep.c
index ba4e943a01a82a2c3c6dd847c6dd612227159b82..fa90243d9648bfcb9bf8515f4298ce463b882998 100644 (file)
--- a/gdb/ppc-nbsd-tdep.c
+++ b/gdb/ppc-nbsd-tdep.c
@@ -78,7 +78,7 @@ ppcnbsd_return_value (struct gdbarch *gdbarch, struct value *function,
   if ((valtype->code () == TYPE_CODE_STRUCT
        || valtype->code () == TYPE_CODE_UNION)
       && !((TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 8)
-           && TYPE_VECTOR (valtype))
+           && valtype->is_vector ())
       && !(TYPE_LENGTH (valtype) == 1
           || TYPE_LENGTH (valtype) == 2
           || TYPE_LENGTH (valtype) == 4

diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index f0f618c5eba5e7e85a442df925bb733d876f362d..08c65cff2ffd7b4ba697b24e9196b48f658d14e2 100644 (file)
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -335,7 +335,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            }
          else if (len < 16
                   && type->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type)
+                  && type->is_vector ()
                   && opencl_abi)
            {
              /* OpenCL vectors shorter than 16 bytes are passed as if
@@ -422,7 +422,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            }
          else if (len >= 16
                   && type->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type)
+                  && type->is_vector ()
                   && opencl_abi)
            {
              /* OpenCL vectors 16 bytes or longer are passed as if
@@ -451,7 +451,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            }
          else if (len == 16
                   && type->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type)
+                  && type->is_vector ()
                   && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
            {
              /* Vector parameter passed in an Altivec register, or
@@ -472,7 +472,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            }
          else if (len == 8
                   && type->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type)
+                  && type->is_vector ()
                   && tdep->vector_abi == POWERPC_VEC_SPE)
            {
              /* Vector parameter passed in an e500 register, or when
@@ -509,7 +509,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                  /* Structs and large values are put in an
                     aligned stack slot ...  */
                  if (type->code () == TYPE_CODE_ARRAY
-                     && TYPE_VECTOR (type)
+                     && type->is_vector ()
                      && len >= 16)
                    structoffset = align_up (structoffset, 16);
                  else
@@ -804,7 +804,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
   /* OpenCL vectors < 16 bytes are returned as distinct
      scalars in f1..f2 or r3..r10.  */
   if (type->code () == TYPE_CODE_ARRAY
-      && TYPE_VECTOR (type)
+      && type->is_vector ()
       && TYPE_LENGTH (type) < 16
       && opencl_abi)
     {
@@ -858,7 +858,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
     }
   /* OpenCL vectors >= 16 bytes are returned in v2..v9.  */
   if (type->code () == TYPE_CODE_ARRAY
-      && TYPE_VECTOR (type)
+      && type->is_vector ()
       && TYPE_LENGTH (type) >= 16
       && opencl_abi)
     {
@@ -880,7 +880,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
     }
   if (TYPE_LENGTH (type) == 16
       && type->code () == TYPE_CODE_ARRAY
-      && TYPE_VECTOR (type)
+      && type->is_vector ()
       && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
     {
       if (readbuf)
@@ -897,7 +897,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
     }
   if (TYPE_LENGTH (type) == 16
       && type->code () == TYPE_CODE_ARRAY
-      && TYPE_VECTOR (type)
+      && type->is_vector ()
       && tdep->vector_abi == POWERPC_VEC_GENERIC)
     {
       /* GCC -maltivec -mabi=no-altivec returns vectors in r3/r4/r5/r6.
@@ -921,7 +921,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type,
     }
   if (TYPE_LENGTH (type) == 8
       && type->code () == TYPE_CODE_ARRAY
-      && TYPE_VECTOR (type)
+      && type->is_vector ()
       && tdep->vector_abi == POWERPC_VEC_SPE)
     {
       /* The e500 ABI places return values for the 64-bit DSP types
@@ -1101,7 +1101,7 @@ ppc64_aggregate_candidate (struct type *type,
       break;
 
     case TYPE_CODE_ARRAY:
-      if (TYPE_VECTOR (type))
+      if (type->is_vector ())
        {
          if (!*field_type)
            *field_type = type;
@@ -1186,7 +1186,7 @@ ppc64_elfv2_abi_homogeneous_aggregate (struct type *type,
      complex types can be elements of homogeneous aggregates.  */
   if (type->code () == TYPE_CODE_STRUCT
       || type->code () == TYPE_CODE_UNION
-      || (type->code () == TYPE_CODE_ARRAY && !TYPE_VECTOR (type)))
+      || (type->code () == TYPE_CODE_ARRAY && !type->is_vector ()))
     {
       struct type *field_type = NULL;
       LONGEST field_count = ppc64_aggregate_candidate (type, &field_type);
@@ -1428,7 +1428,7 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch,
       ppc64_sysv_abi_push_val (gdbarch, val, TYPE_LENGTH (type), 0, argpos);
       ppc64_sysv_abi_push_freg (gdbarch, type, val, argpos);
     }
-  else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+  else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
           && tdep->vector_abi == POWERPC_VEC_ALTIVEC
           && TYPE_LENGTH (type) == 16)
     {
@@ -1436,7 +1436,7 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch,
       ppc64_sysv_abi_push_val (gdbarch, val, TYPE_LENGTH (type), 16, argpos);
       ppc64_sysv_abi_push_vreg (gdbarch, val, argpos);
     }
-  else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+  else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
           && TYPE_LENGTH (type) >= 16)
     {
       /* Non-Altivec vectors are passed by reference.  */
@@ -1520,7 +1520,7 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch,
                    || eltype->code () == TYPE_CODE_DECFLOAT)
                  ppc64_sysv_abi_push_freg (gdbarch, eltype, elval, argpos);
                else if (eltype->code () == TYPE_CODE_ARRAY
-                        && TYPE_VECTOR (eltype)
+                        && eltype->is_vector ()
                         && tdep->vector_abi == POWERPC_VEC_ALTIVEC
                         && TYPE_LENGTH (eltype) == 16)
                  ppc64_sysv_abi_push_vreg (gdbarch, elval, argpos);
@@ -1644,7 +1644,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch,
              ppc64_sysv_abi_push_param (gdbarch, eltype,
                                         val + TYPE_LENGTH (eltype), &argpos);
            }
-         else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
+         else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
                   && opencl_abi)
            {
              /* OpenCL vectors shorter than 16 bytes are passed as if
@@ -1856,7 +1856,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
 
   /* AltiVec vectors are returned in VRs starting at v2.  */
   if (TYPE_LENGTH (valtype) == 16
-      && valtype->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
+      && valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
       && tdep->vector_abi == POWERPC_VEC_ALTIVEC)
     {
       int regnum = tdep->ppc_vr0_regnum + 2 + index;
@@ -1870,7 +1870,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype,
 
   /* Short vectors are returned in GPRs starting at r3.  */
   if (TYPE_LENGTH (valtype) <= 8
-      && valtype->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype))
+      && valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ())
     {
       int regnum = tdep->ppc_gp0_regnum + 3 + index;
       int offset = 0;
@@ -1938,7 +1938,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
   /* OpenCL vectors shorter than 16 bytes are returned as if
      a series of independent scalars; OpenCL vectors 16 bytes
      or longer are returned as if a series of AltiVec vectors.  */
-  if (valtype->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
+  if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
       && opencl_abi)
     {
       if (TYPE_LENGTH (valtype) < 16)
@@ -1975,7 +1975,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
 
   /* Small character arrays are returned, right justified, in r3.  */
   if (valtype->code () == TYPE_CODE_ARRAY
-      && !TYPE_VECTOR (valtype)
+      && !valtype->is_vector ()
       && TYPE_LENGTH (valtype) <= 8
       && TYPE_TARGET_TYPE (valtype)->code () == TYPE_CODE_INT
       && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
@@ -1999,7 +1999,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
       && (eltype->code () == TYPE_CODE_FLT
          || eltype->code () == TYPE_CODE_DECFLOAT
          || (eltype->code () == TYPE_CODE_ARRAY
-             && TYPE_VECTOR (eltype)
+             && eltype->is_vector ()
              && tdep->vector_abi == POWERPC_VEC_ALTIVEC
              && TYPE_LENGTH (eltype) == 16)))
     {
@@ -2025,7 +2025,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function,
       && (valtype->code () == TYPE_CODE_STRUCT
          || valtype->code () == TYPE_CODE_UNION
          || (valtype->code () == TYPE_CODE_ARRAY
-             && !TYPE_VECTOR (valtype))))
+             && !valtype->is_vector ())))
     {
       int n_regs = ((TYPE_LENGTH (valtype) + tdep->wordsize - 1)
                    / tdep->wordsize);

diff --git a/gdb/reggroups.c b/gdb/reggroups.c
index 83d7b49e330b9424eb93ea6694e52ca68d5407ca..c092c9c30b90f50ad297442ca5baf411338b13dd 100644 (file)
--- a/gdb/reggroups.c
+++ b/gdb/reggroups.c
@@ -201,7 +201,7 @@ default_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
     return 0;
   if (group == all_reggroup)
     return 1;
-  vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
+  vector_p = register_type (gdbarch, regnum)->is_vector ();
   float_p = (register_type (gdbarch, regnum)->code () == TYPE_CODE_FLT
             || (register_type (gdbarch, regnum)->code ()
                 == TYPE_CODE_DECFLOAT));

diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c
index 0e8cf38e50c1c2ff4589b33b0919bdab72bbfeb4..a7c25642d0352d89df6d2f7ac576a81afed0bba7 100644 (file)
--- a/gdb/riscv-tdep.c
+++ b/gdb/riscv-tdep.c
@@ -935,7 +935,7 @@ riscv_print_one_register_info (struct gdbarch *gdbarch,
            {
              /* If not a vector register, print it also according to its
                 natural format.  */
-             if (TYPE_VECTOR (regtype) == 0)
+             if (regtype->is_vector () == 0)
                {
                  get_user_print_options (&opts);
                  opts.deref_ref = 1;
@@ -1772,7 +1772,7 @@ static ULONGEST
 riscv_type_align (gdbarch *gdbarch, type *type)
 {
   type = check_typedef (type);
-  if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     return std::min (TYPE_LENGTH (type), (ULONGEST) BIGGEST_ALIGNMENT);
 
   /* Anything else will be aligned by the generic code.  */

diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c
index 66b75a70249486bd0afdb9733a93670d9e8fbf83..730dd98f67cc128a8a4bdeb6dd12672f47afcac0 100644 (file)
--- a/gdb/rs6000-aix-tdep.c
+++ b/gdb/rs6000-aix-tdep.c
@@ -527,7 +527,7 @@ rs6000_return_value (struct gdbarch *gdbarch, struct value *function,
 
   /* AltiVec extension: Functions that declare a vector data type as a
      return value place that return value in VR2.  */
-  if (valtype->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
+  if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
       && TYPE_LENGTH (valtype) == 16)
     {
       if (readbuf)

diff --git a/gdb/rs6000-lynx178-tdep.c b/gdb/rs6000-lynx178-tdep.c
index 7f1825dc4535e439579ff7f3734e8100a21e495c..54a1bdcb9526ec0e8bed0dc362379beda4f4a87e 100644 (file)
--- a/gdb/rs6000-lynx178-tdep.c
+++ b/gdb/rs6000-lynx178-tdep.c
@@ -274,7 +274,7 @@ rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function,
 
   /* AltiVec extension: Functions that declare a vector data type as a
      return value place that return value in VR2.  */
-  if (valtype->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
+  if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
       && TYPE_LENGTH (valtype) == 16)
     {
       if (readbuf)

diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index efe650ae03613b5cc7d5dde7fb58f5a17d66c8ac..fc374bcd560c61c38b21454772aebdf637af5526 100644 (file)
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -75,7 +75,7 @@ s390_type_align (gdbarch *gdbarch, struct type *t)
          return 8;
 
        case TYPE_CODE_ARRAY:
-         if (TYPE_VECTOR (t))
+         if (t->is_vector ())
            return 8;
          break;
        }
@@ -1697,7 +1697,7 @@ s390_function_arg_vector (struct type *type)
   /* Structs containing just a vector are passed like a vector.  */
   type = s390_effective_inner_type (type, TYPE_LENGTH (type));
 
-  return type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type);
+  return type->code () == TYPE_CODE_ARRAY && type->is_vector ();
 }
 
 /* Determine whether N is a power of two.  */
@@ -2093,7 +2093,7 @@ s390_return_value (struct gdbarch *gdbarch, struct value *function,
       break;
     case TYPE_CODE_ARRAY:
       rvc = (gdbarch_tdep (gdbarch)->vector_abi == S390_VECTOR_ABI_128
-            && TYPE_LENGTH (type) <= 16 && TYPE_VECTOR (type))
+            && TYPE_LENGTH (type) <= 16 && type->is_vector ())
        ? RETURN_VALUE_REGISTER_CONVENTION
        : RETURN_VALUE_STRUCT_CONVENTION;
       break;

diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index 9e00a678a19dc29d6b5b814dce0a01bd3fb03890..681b8009008334ca95098fd1be11d51f845fa1a3 100644 (file)
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -303,7 +303,7 @@ sparc_structure_or_union_p (const struct type *type)
 static bool
 sparc_structure_return_p (const struct type *type)
 {
-  if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       /* Float vectors are always returned by memory.  */
       if (sparc_floating_p (check_typedef (TYPE_TARGET_TYPE (type))))
@@ -331,7 +331,7 @@ sparc_structure_return_p (const struct type *type)
 static bool
 sparc_arg_by_memory_p (const struct type *type)
 {
-  if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       /* Float vectors are always passed by memory.  */
       if (sparc_floating_p (check_typedef (TYPE_TARGET_TYPE (type))))

diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c
index 9d2d053545c287c8b04fe74fc0f081862834aee5..eadad86cce1287bb1d17bd35680e1866d789ff41 100644 (file)
--- a/gdb/target-descriptions.c
+++ b/gdb/target-descriptions.c
@@ -263,7 +263,7 @@ make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
          /* If any of the children of a union are vectors, flag the
             union as a vector also.  This allows e.g. a union of two
             vector types to show up automatically in "info vector".  */
-         if (TYPE_VECTOR (field_gdb_type))
+         if (field_gdb_type->is_vector ())
            m_type->set_is_vector (true);
        }
     }

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 82f11db3d56a4f8166219a1e5abf7c69049fc1cd..c418fc6f55a8007ca8999e3cac491788f38e4a1c 100644 (file)
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -1440,7 +1440,7 @@ value_vector_widen (struct value *scalar_value, struct type *vector_type)
   vector_type = check_typedef (vector_type);
 
   gdb_assert (vector_type->code () == TYPE_CODE_ARRAY
-             && TYPE_VECTOR (vector_type));
+             && vector_type->is_vector ());
 
   if (!get_array_bounds (vector_type, &low_bound, &high_bound))
     error (_("Could not determine the vector bounds"));
@@ -1480,9 +1480,9 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
   type2 = check_typedef (value_type (val2));
 
   t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
-              && TYPE_VECTOR (type1)) ? 1 : 0;
+              && type1->is_vector ()) ? 1 : 0;
   t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
-              && TYPE_VECTOR (type2)) ? 1 : 0;
+              && type2->is_vector ()) ? 1 : 0;
 
   if (!t1_is_vec || !t2_is_vec)
     error (_("Vector operations are only supported among vectors"));
@@ -1525,9 +1525,9 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
   struct type *type1 = check_typedef (value_type (arg1));
   struct type *type2 = check_typedef (value_type (arg2));
   int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type1));
+                  && type1->is_vector ());
   int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
-                  && TYPE_VECTOR (type2));
+                  && type2->is_vector ());
 
   if (!t1_is_vec && !t2_is_vec)
     val = scalar_binop (arg1, arg2, op);
@@ -1767,7 +1767,7 @@ value_pos (struct value *arg1)
   type = check_typedef (value_type (arg1));
 
   if (is_integral_type (type) || is_floating_value (arg1)
-      || (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+      || (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
       || type->code () == TYPE_CODE_COMPLEX)
     return value_from_contents (type, value_contents (arg1));
   else
@@ -1784,7 +1784,7 @@ value_neg (struct value *arg1)
 
   if (is_integral_type (type) || is_floating_type (type))
     return value_binop (value_from_longest (type, 0), arg1, BINOP_SUB);
-  else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       struct value *tmp, *val = allocate_value (type);
       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
@@ -1826,7 +1826,7 @@ value_complement (struct value *arg1)
 
   if (is_integral_type (type))
     val = value_from_longest (type, ~value_as_long (arg1));
-  else if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+  else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
     {
       struct value *tmp;
       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));

diff --git a/gdb/valops.c b/gdb/valops.c
index aba4c70d45e2c437885cc6498231f98f44afa91d..da2881a3469234b505857bc7c349ba02a318fbb0 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -416,7 +416,7 @@ value_cast (struct type *type, struct value *arg2)
 
   if (current_language->c_style_arrays
       && type2->code () == TYPE_CODE_ARRAY
-      && !TYPE_VECTOR (type2))
+      && !type2->is_vector ())
     arg2 = value_coerce_array (arg2);
 
   if (type2->code () == TYPE_CODE_FUNC)
@@ -529,11 +529,11 @@ value_cast (struct type *type, struct value *arg2)
         minus one, instead of biasing the normal case.  */
       return value_from_longest (to_type, -1);
     }
-  else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
-          && code2 == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)
+  else if (code1 == TYPE_CODE_ARRAY && type->is_vector ()
+          && code2 == TYPE_CODE_ARRAY && type2->is_vector ()
           && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
     error (_("Cannot convert between vector values of different sizes"));
-  else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && scalar
+  else if (code1 == TYPE_CODE_ARRAY && type->is_vector () && scalar
           && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
     error (_("can only cast scalar to vector of same size"));
   else if (code1 == TYPE_CODE_VOID)
@@ -854,7 +854,7 @@ value_one (struct type *type)
     {
       val = value_from_longest (type, (LONGEST) 1);
     }
-  else if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+  else if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
     {
       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
       int i;
@@ -1361,7 +1361,7 @@ value_must_coerce_to_target (struct value *val)
   switch (valtype->code ())
     {
     case TYPE_CODE_ARRAY:
-      return TYPE_VECTOR (valtype) ? 0 : 1;
+      return valtype->is_vector () ? 0 : 1;
     case TYPE_CODE_STRING:
       return true;
     default:

diff --git a/gdb/value.c b/gdb/value.c
index f5eb5641d9beae2afb79524de4b25204658c67ee..8f4030e90b203ec78a52c365415173c427b9fc50 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -3687,7 +3687,7 @@ coerce_array (struct value *arg)
   switch (type->code ())
     {
     case TYPE_CODE_ARRAY:
-      if (!TYPE_VECTOR (type) && current_language->c_style_arrays)
+      if (!type->is_vector () && current_language->c_style_arrays)
        arg = value_coerce_array (arg);
       break;
     case TYPE_CODE_FUNC: