X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fopencl-lang.c;h=03699b1425166f9a2c74a771d7f837c28c69e4c3;hb=258876ee34a4b656c754355cf175a825e0db80f3;hp=088d49af32c28e6d2c23bbb1ff6a7899a0b508bc;hpb=f4b8a18de7f165283091323b11e9e363dadb8b62;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c index 088d49af32..03699b1425 100644 --- a/gdb/opencl-lang.c +++ b/gdb/opencl-lang.c @@ -1,5 +1,5 @@ /* OpenCL language support for GDB, the GNU debugger. - Copyright (C) 2010 Free Software Foundation, Inc. + Copyright (C) 2010-2019 Free Software Foundation, Inc. Contributed by Ken Werner . @@ -19,17 +19,13 @@ along with this program. If not, see . */ #include "defs.h" -#include "gdb_string.h" #include "gdbtypes.h" #include "symtab.h" #include "expression.h" #include "parser-defs.h" -#include "symtab.h" #include "language.h" +#include "varobj.h" #include "c-lang.h" -#include "gdb_assert.h" - -extern void _initialize_opencl_language (void); /* This macro generates enum values from a given type. */ @@ -66,47 +62,12 @@ 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 * +static struct type ** builtin_opencl_type (struct gdbarch *gdbarch) { - return gdbarch_data (gdbarch, opencl_type_data); + return (struct type **) gdbarch_data (gdbarch, opencl_type_data); } /* Returns the corresponding OpenCL vector type from the given type code, @@ -121,7 +82,7 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code, 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) @@ -191,11 +152,11 @@ struct lval_closure static struct lval_closure * allocate_lval_closure (int *indices, int n, struct value *val) { - struct lval_closure *c = XZALLOC (struct lval_closure); + struct lval_closure *c = XCNEW (struct lval_closure); c->refc = 1; c->n = n; - c->indices = XCALLOC (n, int); + c->indices = XCNEWVEC (int, n); memcpy (c->indices, indices, n * sizeof (int)); value_incref (val); /* Increment the reference counter of the value. */ c->val = val; @@ -209,8 +170,8 @@ lval_func_read (struct value *v) struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); struct type *type = check_typedef (value_type (v)); struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val))); - int offset = value_offset (v); - int elsize = TYPE_LENGTH (eltype); + LONGEST offset = value_offset (v); + LONGEST elsize = TYPE_LENGTH (eltype); int n, i, j = 0; LONGEST lowb = 0; LONGEST highb = 0; @@ -238,8 +199,8 @@ lval_func_write (struct value *v, struct value *fromval) struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); struct type *type = check_typedef (value_type (v)); struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val))); - int offset = value_offset (v); - int elsize = TYPE_LENGTH (eltype); + LONGEST offset = value_offset (v); + LONGEST elsize = TYPE_LENGTH (eltype); int n, i, j = 0; LONGEST lowb = 0; LONGEST highb = 0; @@ -275,10 +236,12 @@ lval_func_write (struct value *v, struct value *fromval) value_free_to_mark (mark); } -/* Return nonzero if all bits in V within OFFSET and LENGTH are valid. */ +/* Return nonzero if bits in V from OFFSET and LENGTH represent a + synthetic pointer. */ static int -lval_func_check_validity (const struct value *v, int offset, int length) +lval_func_check_synthetic_pointer (const struct value *v, + LONGEST offset, int length) { struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); /* Size of the target type in bits. */ @@ -298,35 +261,18 @@ lval_func_check_validity (const struct value *v, int offset, int length) for (i = start; i < end; i++) { - int startoffset = (i == start) ? startrest : 0; - int length = (i == end) ? endrest : elsize; + int comp_offset = (i == start) ? startrest : 0; + int comp_length = (i == end) ? endrest : elsize; - if (!value_bits_valid (c->val, c->indices[i] * elsize + startoffset, - length)) + if (!value_bits_synthetic_pointer (c->val, + c->indices[i] * elsize + comp_offset, + comp_length)) return 0; } return 1; } -/* Return nonzero if any bit in V is valid. */ - -static int -lval_func_check_any_valid (const struct value *v) -{ - struct lval_closure *c = (struct lval_closure *) value_computed_closure (v); - /* Size of the target type in bits. */ - int elsize = - TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8; - int i; - - for (i = 0; i < c->n; i++) - if (value_bits_valid (c->val, c->indices[i] * elsize, elsize)) - return 1; - - return 0; -} - static void * lval_func_copy_closure (const struct value *v) { @@ -346,18 +292,19 @@ lval_func_free_closure (struct value *v) if (c->refc == 0) { + value_decref (c->val); /* Decrement the reference counter of the value. */ xfree (c->indices); xfree (c); - value_free (c->val); /* Decrement the reference counter of the value. */ } } -static struct lval_funcs opencl_value_funcs = +static const struct lval_funcs opencl_value_funcs = { lval_func_read, lval_func_write, - lval_func_check_validity, - lval_func_check_any_valid, + NULL, /* indirect */ + NULL, /* coerce_ref */ + lval_func_check_synthetic_pointer, lval_func_copy_closure, lval_func_free_closure }; @@ -678,6 +625,58 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2, return ret; } +/* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in + here from valops.c:value_cast, opencl is different only in the + behaviour of scalar to vector casting. As far as possibly we're going + to try and delegate back to the standard value_cast function. */ + +static struct value * +opencl_value_cast (struct type *type, struct value *arg) +{ + if (type != value_type (arg)) + { + /* Casting scalar to vector is a special case for OpenCL, scalar + is cast to element type of vector then replicated into each + element of the vector. First though, we need to work out if + this is a scalar to vector cast; code lifted from + valops.c:value_cast. */ + enum type_code code1, code2; + struct type *to_type; + int scalar; + + to_type = check_typedef (type); + + code1 = TYPE_CODE (to_type); + code2 = TYPE_CODE (check_typedef (value_type (arg))); + + if (code2 == TYPE_CODE_REF) + code2 = TYPE_CODE (check_typedef (value_type (coerce_ref (arg)))); + + scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL + || code2 == TYPE_CODE_CHAR || code2 == TYPE_CODE_FLT + || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM + || code2 == TYPE_CODE_RANGE); + + if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (to_type) && scalar) + { + struct type *eltype; + + /* Cast to the element type of the vector here as + value_vector_widen will error if the scalar value is + truncated by the cast. To avoid the error, cast (and + possibly truncate) here. */ + eltype = check_typedef (TYPE_TARGET_TYPE (to_type)); + arg = value_cast (eltype, arg); + + return value_vector_widen (arg, type); + } + else + /* Standard cast handler. */ + arg = value_cast (type, arg); + } + return arg; +} + /* Perform a relational operation on two operands. */ static struct value * @@ -713,7 +712,7 @@ opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2, if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t)) error (_("Argument to operation not a number or boolean.")); - *v = value_cast (t1_is_vec ? type1 : type2, *v); + *v = opencl_value_cast (t1_is_vec ? type1 : type2, *v); val = vector_relop (exp, arg1, arg2, op); } @@ -735,6 +734,46 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp, switch (op) { + /* Handle assignment and cast operators to support OpenCL-style + scalar-to-vector widening. */ + case BINOP_ASSIGN: + (*pos)++; + arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); + type1 = value_type (arg1); + arg2 = evaluate_subexp (type1, exp, pos, noside); + + if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) + return arg1; + + if (deprecated_value_modifiable (arg1) + && VALUE_LVAL (arg1) != lval_internalvar) + arg2 = opencl_value_cast (type1, arg2); + + return value_assign (arg1, arg2); + + case UNOP_CAST: + type1 = exp->elts[*pos + 1].type; + (*pos) += 2; + arg1 = evaluate_subexp (type1, exp, pos, noside); + + if (noside == EVAL_SKIP) + return value_from_longest (builtin_type (exp->gdbarch)-> + builtin_int, 1); + + return opencl_value_cast (type1, arg1); + + case UNOP_CAST_TYPE: + (*pos)++; + arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS); + type1 = value_type (arg1); + arg1 = evaluate_subexp (type1, exp, pos, noside); + + if (noside == EVAL_SKIP) + return value_from_longest (builtin_type (exp->gdbarch)-> + builtin_int, 1); + + return opencl_value_cast (type1, arg1); + /* Handle binary relational and equality operators that are either not or differently defined for GNU vectors. */ case BINOP_EQUAL: @@ -772,7 +811,7 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp, if (noside == EVAL_SKIP) { - arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); + evaluate_subexp (NULL_TYPE, exp, pos, noside); return value_from_longest (builtin_type (exp->gdbarch)-> builtin_int, 1); @@ -786,7 +825,8 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp, Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */ int oldpos = *pos; - arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); + arg2 = evaluate_subexp (NULL_TYPE, exp, pos, + EVAL_AVOID_SIDE_EFFECTS); *pos = oldpos; type1 = check_typedef (value_type (arg1)); type2 = check_typedef (value_type (arg2)); @@ -846,12 +886,12 @@ evaluate_subexp_opencl (struct type *expect_type, struct expression *exp, /* Widen the scalar operand to a vector if necessary. */ if (t2_is_vec || !t3_is_vec) { - arg3 = value_cast (type2, arg3); + arg3 = opencl_value_cast (type2, arg3); type3 = value_type (arg3); } else if (!t2_is_vec || t3_is_vec) { - arg2 = value_cast (type3, arg2); + arg2 = opencl_value_cast (type3, arg2); type2 = value_type (arg2); } else if (!t2_is_vec || !t3_is_vec) @@ -937,15 +977,13 @@ Cannot perform conditional operation on vectors with different sizes")); } else { + struct value *v = value_struct_elt (&arg1, NULL, + &exp->elts[pc + 2].string, NULL, + "structure"); + if (noside == EVAL_AVOID_SIDE_EFFECTS) - return - value_zero (lookup_struct_elt_type - (value_type (arg1),&exp->elts[pc + 2].string, 0), - lval_memory); - else - return value_struct_elt (&arg1, NULL, - &exp->elts[pc + 2].string, NULL, - "structure"); + v = value_zero (value_type (v), VALUE_LVAL (v)); + return v; } } default: @@ -955,69 +993,42 @@ Cannot perform conditional operation on vectors with different sizes")); return evaluate_subexp_c (expect_type, exp, pos, noside); } -void +/* Print OpenCL types. */ + +static void +opencl_print_type (struct type *type, const char *varstring, + struct ui_file *stream, int show, int level, + const struct type_print_options *flags) +{ + /* We nearly always defer to C type printing, except that vector + types are considered primitive in OpenCL, and should always + be printed using their TYPE_NAME. */ + if (show > 0) + { + type = check_typedef (type); + if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) + && TYPE_NAME (type) != NULL) + show = 0; + } + + c_print_type (type, varstring, stream, show, level, flags); +} + +static 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 = @@ -1030,133 +1041,144 @@ const struct exp_descriptor exp_descriptor_opencl = evaluate_subexp_opencl }; -const struct language_defn opencl_language_defn = +extern const struct language_defn opencl_language_defn = { "opencl", /* Language name */ + "OpenCL C", language_opencl, range_check_off, - type_check_off, case_sensitive_on, array_row_major, macro_expansion_c, + NULL, &exp_descriptor_opencl, c_parse, - c_error, null_post_parser, c_printchar, /* Print a character constant */ c_printstr, /* Function to print string constant */ c_emit_char, /* Print a single char */ - c_print_type, /* Print a type using appropriate syntax */ + opencl_print_type, /* Print a type using appropriate syntax */ c_print_typedef, /* Print a typedef using appropriate syntax */ c_val_print, /* Print a value using appropriate syntax */ c_value_print, /* Print a top-level value */ + default_read_var_value, /* la_read_var_value */ NULL, /* Language specific skip_trampoline */ NULL, /* name_of_this */ + false, /* la_store_sym_names_in_linkage_form_p */ basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ basic_lookup_transparent_type,/* lookup_transparent_type */ NULL, /* Language specific symbol demangler */ - NULL, /* Language specific class_name_from_physname */ + NULL, + NULL, /* Language specific + class_name_from_physname */ c_op_print_tab, /* expression operators for printing */ 1, /* c-style arrays */ 0, /* String lower bound */ default_word_break_characters, - default_make_symbol_completion_list, + default_collect_symbol_completion_matches, opencl_language_arch_info, default_print_array_index, default_pass_by_reference, c_get_string, + c_watch_location_expression, + NULL, /* la_get_symbol_name_matcher */ + iterate_over_symbols, + default_search_name_hash, + &default_varobj_ops, + NULL, + NULL, LANG_MAGIC }; 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 STRINGIFY(S) #S +#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) = STRINGIFY(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) = STRINGIFY(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) = STRINGIFY(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) = STRINGIFY(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) = STRINGIFY(TYPE ## 16) - - builtin_opencl_type->builtin_char + 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) + + 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 - = arch_boolean_type (gdbarch, 32, 1, "bool"); - builtin_opencl_type->builtin_unsigned_char + types[opencl_primitive_type_bool] + = arch_boolean_type (gdbarch, 8, 1, "bool"); + 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 - = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); + types[opencl_primitive_type_void] + = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void"); - return builtin_opencl_type; + return types; } void _initialize_opencl_language (void) { opencl_type_data = gdbarch_data_register_post_init (build_opencl_types); - add_language (&opencl_language_defn); }