[commit] Simplify OpenCL primitive type handling

["Ulrich Weigand" <uweigand at de dot ibm dot com>]

Hello,

opencl-lang.c maintains two lists of language-specific types, one as a
gdbarch data element of type "struct builtin_opencl_type", and one as the
primitive type vector in struct language_arch_info.

This causes a bit of code duplication, and also this piece of code in
lookup_opencl_vector_type, which is not really portable:
  struct type **types = (struct type **) builtin_opencl_type (gdbarch);

The patch below fixes this by making the gdbarch data element created
by build_opencl_types to be of the proper type and format so that it
can be immediately reused as language primitive type vector.

Tested with no regressions on powerpc64-linux.
Committed to mainline.

Bye,
Ulrich


ChangeLog:

	* opencl-lang.c (STRUCT_OCL_TYPE): Remove.
	(struct builtin_opencl_type): Remove.
	(builtin_opencl_type): Change return type to "struct type **".
	(lookup_opencl_vector_type): Update caller.
	(opencl_language_arch_info): Copy primitive type vector from gdbarch.
	(build_opencl_types): Install plain array of "struct type *"
	instead of "struct builtin_opencl_type".

Index: gdb/opencl-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/opencl-lang.c,v
retrieving revision 1.6
diff -u -p -r1.6 opencl-lang.c
--- gdb/opencl-lang.c	15 Feb 2011 20:09:52 -0000	1.6
+++ gdb/opencl-lang.c	21 Feb 2011 15:44:38 -0000
@@ -66,44 +66,9 @@ enum opencl_primitive_types {
   nr_opencl_primitive_types
 };
 
-/* This macro generates the type struct declarations from a given type.  */
-
-#define STRUCT_OCL_TYPE(TYPE)\
-  struct type *builtin_##TYPE;\
-  struct type *builtin_##TYPE##2;\
-  struct type *builtin_##TYPE##3;\
-  struct type *builtin_##TYPE##4;\
-  struct type *builtin_##TYPE##8;\
-  struct type *builtin_##TYPE##16
-
-struct builtin_opencl_type
-{
-  STRUCT_OCL_TYPE (char);
-  STRUCT_OCL_TYPE (uchar);
-  STRUCT_OCL_TYPE (short);
-  STRUCT_OCL_TYPE (ushort);
-  STRUCT_OCL_TYPE (int);
-  STRUCT_OCL_TYPE (uint);
-  STRUCT_OCL_TYPE (long);
-  STRUCT_OCL_TYPE (ulong);
-  STRUCT_OCL_TYPE (half);
-  STRUCT_OCL_TYPE (float);
-  STRUCT_OCL_TYPE (double);
-  struct type *builtin_bool;
-  struct type *builtin_unsigned_char;
-  struct type *builtin_unsigned_short;
-  struct type *builtin_unsigned_int;
-  struct type *builtin_unsigned_long;
-  struct type *builtin_size_t;
-  struct type *builtin_ptrdiff_t;
-  struct type *builtin_intptr_t;
-  struct type *builtin_uintptr_t;
-  struct type *builtin_void;
-};
-
 static struct gdbarch_data *opencl_type_data;
 
-const struct builtin_opencl_type *
+struct type **
 builtin_opencl_type (struct gdbarch *gdbarch)
 {
   return gdbarch_data (gdbarch, opencl_type_data);
@@ -121,7 +86,7 @@ lookup_opencl_vector_type (struct gdbarc
   int i;
   unsigned int length;
   struct type *type = NULL;
-  struct type **types = (struct type **) builtin_opencl_type (gdbarch);
+  struct type **types = builtin_opencl_type (gdbarch);
 
   /* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16).  */
   if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16)
@@ -997,67 +962,19 @@ Cannot perform conditional operation on 
 
 void
 opencl_language_arch_info (struct gdbarch *gdbarch,
-		      struct language_arch_info *lai)
+			   struct language_arch_info *lai)
 {
-  const struct builtin_opencl_type *builtin = builtin_opencl_type (gdbarch);
+  struct type **types = builtin_opencl_type (gdbarch);
 
-  lai->string_char_type = builtin->builtin_char;
-  lai->primitive_type_vector
-    = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
-			      struct type *);
+  /* Copy primitive types vector from gdbarch.  */
+  lai->primitive_type_vector = types;
 
-/* This macro fills the primitive_type_vector from a given type.  */
-#define FILL_TYPE_VECTOR(LAI, TYPE)\
-  LAI->primitive_type_vector [opencl_primitive_type_##TYPE]\
-    = builtin->builtin_##TYPE;\
-  LAI->primitive_type_vector [opencl_primitive_type_##TYPE##2]\
-    = builtin->builtin_##TYPE##2;\
-  LAI->primitive_type_vector [opencl_primitive_type_##TYPE##3]\
-    = builtin->builtin_##TYPE##3;\
-  LAI->primitive_type_vector [opencl_primitive_type_##TYPE##4]\
-    = builtin->builtin_##TYPE##4;\
-  LAI->primitive_type_vector [opencl_primitive_type_##TYPE##8]\
-    = builtin->builtin_##TYPE##8;\
-  LAI->primitive_type_vector [opencl_primitive_type_##TYPE##16]\
-    = builtin->builtin_##TYPE##16
-
-  FILL_TYPE_VECTOR (lai, char);
-  FILL_TYPE_VECTOR (lai, uchar);
-  FILL_TYPE_VECTOR (lai, short);
-  FILL_TYPE_VECTOR (lai, ushort);
-  FILL_TYPE_VECTOR (lai, int);
-  FILL_TYPE_VECTOR (lai, uint);
-  FILL_TYPE_VECTOR (lai, long);
-  FILL_TYPE_VECTOR (lai, ulong);
-  FILL_TYPE_VECTOR (lai, half);
-  FILL_TYPE_VECTOR (lai, float);
-  FILL_TYPE_VECTOR (lai, double);
-  lai->primitive_type_vector [opencl_primitive_type_bool]
-    = builtin->builtin_bool;
-  lai->primitive_type_vector [opencl_primitive_type_unsigned_char]
-    = builtin->builtin_unsigned_char;
-  lai->primitive_type_vector [opencl_primitive_type_unsigned_short]
-    = builtin->builtin_unsigned_short;
-  lai->primitive_type_vector [opencl_primitive_type_unsigned_int]
-    = builtin->builtin_unsigned_int;
-  lai->primitive_type_vector [opencl_primitive_type_unsigned_long]
-    = builtin->builtin_unsigned_long;
-  lai->primitive_type_vector [opencl_primitive_type_half]
-    = builtin->builtin_half;
-  lai->primitive_type_vector [opencl_primitive_type_size_t]
-    = builtin->builtin_size_t;
-  lai->primitive_type_vector [opencl_primitive_type_ptrdiff_t]
-    = builtin->builtin_ptrdiff_t;
-  lai->primitive_type_vector [opencl_primitive_type_intptr_t]
-    = builtin->builtin_intptr_t;
-  lai->primitive_type_vector [opencl_primitive_type_uintptr_t]
-    = builtin->builtin_uintptr_t;
-  lai->primitive_type_vector [opencl_primitive_type_void]
-    = builtin->builtin_void;
+  /* Type of elements of strings.  */
+  lai->string_char_type = types [opencl_primitive_type_char];
 
   /* Specifies the return type of logical and relational operations.  */
   lai->bool_type_symbol = "int";
-  lai->bool_type_default = builtin->builtin_int;
+  lai->bool_type_default = types [opencl_primitive_type_int];
 }
 
 const struct exp_descriptor exp_descriptor_opencl =
@@ -1112,87 +1029,88 @@ const struct language_defn opencl_langua
 static void *
 build_opencl_types (struct gdbarch *gdbarch)
 {
-  struct builtin_opencl_type *builtin_opencl_type
-    = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_opencl_type);
+  struct type **types
+    = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
+			      struct type *);
 
 /* Helper macro to create strings.  */
 #define OCL_STRING(S) #S
 /* This macro allocates and assigns the type struct pointers
    for the vector types.  */
 #define BUILD_OCL_VTYPES(TYPE)\
-  builtin_opencl_type->builtin_##TYPE##2\
-    = init_vector_type (builtin_opencl_type->builtin_##TYPE, 2);\
-  TYPE_NAME (builtin_opencl_type->builtin_##TYPE##2) = OCL_STRING(TYPE ## 2);\
-  builtin_opencl_type->builtin_##TYPE##3\
-    = init_vector_type (builtin_opencl_type->builtin_##TYPE, 3);\
-  TYPE_NAME (builtin_opencl_type->builtin_##TYPE##3) = OCL_STRING(TYPE ## 3);\
-  TYPE_LENGTH (builtin_opencl_type->builtin_##TYPE##3)\
-    = 4 * TYPE_LENGTH (builtin_opencl_type->builtin_##TYPE);\
-  builtin_opencl_type->builtin_##TYPE##4\
-    = init_vector_type (builtin_opencl_type->builtin_##TYPE, 4);\
-  TYPE_NAME (builtin_opencl_type->builtin_##TYPE##4) = OCL_STRING(TYPE ## 4);\
-  builtin_opencl_type->builtin_##TYPE##8\
-    = init_vector_type (builtin_opencl_type->builtin_##TYPE, 8);\
-  TYPE_NAME (builtin_opencl_type->builtin_##TYPE##8) = OCL_STRING(TYPE ## 8);\
-  builtin_opencl_type->builtin_##TYPE##16\
-    = init_vector_type (builtin_opencl_type->builtin_##TYPE, 16);\
-  TYPE_NAME (builtin_opencl_type->builtin_##TYPE##16) = OCL_STRING(TYPE ## 16)
+  types[opencl_primitive_type_##TYPE##2] \
+    = init_vector_type (types[opencl_primitive_type_##TYPE], 2); \
+  TYPE_NAME (types[opencl_primitive_type_##TYPE##2]) = OCL_STRING(TYPE ## 2); \
+  types[opencl_primitive_type_##TYPE##3] \
+    = init_vector_type (types[opencl_primitive_type_##TYPE], 3); \
+  TYPE_NAME (types[opencl_primitive_type_##TYPE##3]) = OCL_STRING(TYPE ## 3); \
+  TYPE_LENGTH (types[opencl_primitive_type_##TYPE##3]) \
+    = 4 * TYPE_LENGTH (types[opencl_primitive_type_##TYPE]); \
+  types[opencl_primitive_type_##TYPE##4] \
+    = init_vector_type (types[opencl_primitive_type_##TYPE], 4); \
+  TYPE_NAME (types[opencl_primitive_type_##TYPE##4]) = OCL_STRING(TYPE ## 4); \
+  types[opencl_primitive_type_##TYPE##8] \
+    = init_vector_type (types[opencl_primitive_type_##TYPE], 8); \
+  TYPE_NAME (types[opencl_primitive_type_##TYPE##8]) = OCL_STRING(TYPE ## 8); \
+  types[opencl_primitive_type_##TYPE##16] \
+    = init_vector_type (types[opencl_primitive_type_##TYPE], 16); \
+  TYPE_NAME (types[opencl_primitive_type_##TYPE##16]) = OCL_STRING(TYPE ## 16)
 
-  builtin_opencl_type->builtin_char
+  types[opencl_primitive_type_char]
     = arch_integer_type (gdbarch, 8, 0, "char");
   BUILD_OCL_VTYPES (char);
-  builtin_opencl_type->builtin_uchar
+  types[opencl_primitive_type_uchar]
     = arch_integer_type (gdbarch, 8, 1, "uchar");
   BUILD_OCL_VTYPES (uchar);
-  builtin_opencl_type->builtin_short
+  types[opencl_primitive_type_short]
     = arch_integer_type (gdbarch, 16, 0, "short");
   BUILD_OCL_VTYPES (short);
-  builtin_opencl_type->builtin_ushort
+  types[opencl_primitive_type_ushort]
     = arch_integer_type (gdbarch, 16, 1, "ushort");
   BUILD_OCL_VTYPES (ushort);
-  builtin_opencl_type->builtin_int
+  types[opencl_primitive_type_int]
     = arch_integer_type (gdbarch, 32, 0, "int");
   BUILD_OCL_VTYPES (int);
-  builtin_opencl_type->builtin_uint
+  types[opencl_primitive_type_uint]
     = arch_integer_type (gdbarch, 32, 1, "uint");
   BUILD_OCL_VTYPES (uint);
-  builtin_opencl_type->builtin_long
+  types[opencl_primitive_type_long]
     = arch_integer_type (gdbarch, 64, 0, "long");
   BUILD_OCL_VTYPES (long);
-  builtin_opencl_type->builtin_ulong
+  types[opencl_primitive_type_ulong]
     = arch_integer_type (gdbarch, 64, 1, "ulong");
   BUILD_OCL_VTYPES (ulong);
-  builtin_opencl_type->builtin_half
+  types[opencl_primitive_type_half]
     = arch_float_type (gdbarch, 16, "half", floatformats_ieee_half);
   BUILD_OCL_VTYPES (half);
-  builtin_opencl_type->builtin_float
+  types[opencl_primitive_type_float]
     = arch_float_type (gdbarch, 32, "float", floatformats_ieee_single);
   BUILD_OCL_VTYPES (float);
-  builtin_opencl_type->builtin_double
+  types[opencl_primitive_type_double]
     = arch_float_type (gdbarch, 64, "double", floatformats_ieee_double);
   BUILD_OCL_VTYPES (double);
-  builtin_opencl_type->builtin_bool
+  types[opencl_primitive_type_bool]
     = arch_boolean_type (gdbarch, 8, 1, "bool");
-  builtin_opencl_type->builtin_unsigned_char
+  types[opencl_primitive_type_unsigned_char]
     = arch_integer_type (gdbarch, 8, 1, "unsigned char");
-  builtin_opencl_type->builtin_unsigned_short
+  types[opencl_primitive_type_unsigned_short]
     = arch_integer_type (gdbarch, 16, 1, "unsigned short");
-  builtin_opencl_type->builtin_unsigned_int
+  types[opencl_primitive_type_unsigned_int]
     = arch_integer_type (gdbarch, 32, 1, "unsigned int");
-  builtin_opencl_type->builtin_unsigned_long
+  types[opencl_primitive_type_unsigned_long]
     = arch_integer_type (gdbarch, 64, 1, "unsigned long");
-  builtin_opencl_type->builtin_size_t
+  types[opencl_primitive_type_size_t]
     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t");
-  builtin_opencl_type->builtin_ptrdiff_t
+  types[opencl_primitive_type_ptrdiff_t]
     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t");
-  builtin_opencl_type->builtin_intptr_t
+  types[opencl_primitive_type_intptr_t]
     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t");
-  builtin_opencl_type->builtin_uintptr_t
+  types[opencl_primitive_type_uintptr_t]
     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t");
-  builtin_opencl_type->builtin_void
+  types[opencl_primitive_type_void]
     = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
 
-  return builtin_opencl_type;
+  return types;
 }
 
 void
-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com