/* OpenCL language support for GDB, the GNU debugger.
- Copyright (C) 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2010-2020 Free Software Foundation, Inc.
Contributed by Ken Werner <ken.werner@de.ibm.com>.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#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);
+#include "gdbarch.h"
/* This macro generates enum values from a given type. */
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,
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)
{
LONGEST lowb, highb;
- if (TYPE_CODE (types[i]) == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
+ if (types[i]->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
&& get_array_bounds (types[i], &lowb, &highb)
- && TYPE_CODE (TYPE_TARGET_TYPE (types[i])) == code
+ && TYPE_TARGET_TYPE (types[i])->code () == code
&& TYPE_UNSIGNED (TYPE_TARGET_TYPE (types[i])) == flag_unsigned
&& TYPE_LENGTH (TYPE_TARGET_TYPE (types[i])) == el_length
&& TYPE_LENGTH (types[i]) == length
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;
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;
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ if (type->code () == TYPE_CODE_ARRAY
&& !get_array_bounds (type, &lowb, &highb))
error (_("Could not determine the vector bounds"));
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;
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ if (type->code () == TYPE_CODE_ARRAY
&& !get_array_bounds (type, &lowb, &highb))
error (_("Could not determine the vector bounds"));
value_free_to_mark (mark);
}
-/* Return nonzero if all bits in V within OFFSET and LENGTH are valid. */
-
-static int
-lval_func_check_validity (const struct value *v, int offset, int length)
-{
- 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 startrest = offset % elsize;
- int start = offset / elsize;
- int endrest = (offset + length) % elsize;
- int end = (offset + length) / elsize;
- int i;
-
- if (endrest)
- end++;
-
- if (end > c->n)
- return 0;
-
- for (i = start; i < end; i++)
- {
- int startoffset = (i == start) ? startrest : 0;
- int length = (i == end) ? endrest : elsize;
-
- if (!value_bits_valid (c->val, c->indices[i] * elsize + startoffset,
- 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;
-}
-
/* Return nonzero if bits in V from OFFSET and LENGTH represent a
synthetic pointer. */
static int
lval_func_check_synthetic_pointer (const struct value *v,
- int offset, int length)
+ LONGEST offset, int length)
{
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
/* Size of the target type in bits. */
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_synthetic_pointer (c->val,
- c->indices[i] * elsize + startoffset,
- length))
+ c->indices[i] * elsize + comp_offset,
+ comp_length))
return 0;
}
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,
+ NULL, /* indirect */
+ NULL, /* coerce_ref */
lval_func_check_synthetic_pointer,
lval_func_copy_closure,
lval_func_free_closure
/* Multiple components of the vector are requested which means the
resulting type is a vector as well. */
struct type *dst_type =
- lookup_opencl_vector_type (gdbarch, TYPE_CODE (elm_type),
+ lookup_opencl_vector_type (gdbarch, elm_type->code (),
TYPE_LENGTH (elm_type),
TYPE_UNSIGNED (elm_type), n);
struct type *rettype;
struct value *ret;
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
+ if (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
{
struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
LONGEST lowb, highb;
type1 = check_typedef (value_type (val1));
type2 = check_typedef (value_type (val2));
- t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
- t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
+ t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
+ t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
if (!t1_is_vec || !t2_is_vec)
error (_("Vector operations are not supported on scalar types"));
error (_("Could not determine the vector bounds"));
/* Check whether the vector types are compatible. */
- if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
+ if (eltype1->code () != eltype2->code ()
|| TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
|| TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
|| lowb1 != lowb2 || highb1 != highb2)
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 = to_type->code ();
+ code2 = check_typedef (value_type (arg))->code ();
+
+ if (code2 == TYPE_CODE_REF)
+ code2 = check_typedef (value_type (coerce_ref(arg)))->code ();
+
+ 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 *
struct value *val;
struct type *type1 = check_typedef (value_type (arg1));
struct type *type2 = check_typedef (value_type (arg2));
- int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
+ int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1));
- int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
+ int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type2));
if (!t1_is_vec && !t2_is_vec)
struct value **v = t1_is_vec ? &arg2 : &arg1;
struct type *t = t1_is_vec ? type2 : type1;
- if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t))
+ if (t->code () != 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);
}
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:
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);
else
{
/* For scalar operations we need to avoid evaluating operands
- unecessarily. However, for vector operations we always need to
+ unnecessarily. However, for vector operations we always need to
evaluate both operands. Unfortunately we only know which of the
two cases apply after we know the type of the second operand.
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));
- if ((TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
- || (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
+ if ((type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ || (type2->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
{
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
(*pos)++;
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
type1 = check_typedef (value_type (arg1));
- if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
{
struct value *arg3, *tmp, *ret;
struct type *eltype2, *type3, *eltype3;
type2 = check_typedef (value_type (arg2));
type3 = check_typedef (value_type (arg3));
t2_is_vec
- = TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
+ = type2->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
t3_is_vec
- = TYPE_CODE (type3) == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
+ = type3->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
/* 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)
error (_("Could not determine the vector bounds"));
/* Throw an error if the types of arg2 or arg3 are incompatible. */
- if (TYPE_CODE (eltype2) != TYPE_CODE (eltype3)
+ if (eltype2->code () != eltype3->code ()
|| TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3)
|| TYPE_UNSIGNED (eltype2) != TYPE_UNSIGNED (eltype3)
|| lowb2 != lowb3 || highb2 != highb3)
return value_from_longest (builtin_type (exp->gdbarch)->
builtin_int, 1);
}
- else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ else if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
{
return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
noside);
}
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:
return evaluate_subexp_c (expect_type, exp, pos, noside);
}
-void
-opencl_language_arch_info (struct gdbarch *gdbarch,
- struct language_arch_info *lai)
-{
- const struct builtin_opencl_type *builtin = 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 *);
-
-/* 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;
-
- /* Specifies the return type of logical and relational operations. */
- lai->bool_type_symbol = "int";
- lai->bool_type_default = builtin->builtin_int;
-}
-
const struct exp_descriptor exp_descriptor_opencl =
{
print_subexp_standard,
evaluate_subexp_opencl
};
-const struct language_defn opencl_language_defn =
+/* Constant data representing the OpenCL language. */
+extern const struct language_data opencl_language_data =
{
"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 */
c_print_typedef, /* Print a typedef using appropriate syntax */
- c_val_print, /* Print a value using appropriate syntax */
+ c_value_print_inner, /* la_value_print_inner */
c_value_print, /* Print a top-level 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, /* 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,
- opencl_language_arch_info,
- default_print_array_index,
- default_pass_by_reference,
- c_get_string,
- LANG_MAGIC
+ default_collect_symbol_completion_matches,
+ c_watch_location_expression,
+ NULL, /* la_get_symbol_name_matcher */
+ &default_varobj_ops,
+ NULL,
+ c_is_string_type_p,
+ "{...}" /* la_struct_too_deep_ellipsis */
+};
+
+/* Class representing the OpenCL language. */
+
+class opencl_language : public language_defn
+{
+public:
+ opencl_language ()
+ : language_defn (language_opencl, opencl_language_data)
+ { /* Nothing. */ }
+
+ /* See language.h. */
+ void language_arch_info (struct gdbarch *gdbarch,
+ struct language_arch_info *lai) const override
+ {
+ struct type **types = builtin_opencl_type (gdbarch);
+
+ /* Copy primitive types vector from gdbarch. */
+ lai->primitive_type_vector = types;
+
+ /* 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 = types [opencl_primitive_type_int];
+ }
+
+ /* See language.h. */
+
+ void print_type (struct type *type, const char *varstring,
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags) const override
+ {
+ /* 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_CODE_ARRAY && TYPE_VECTOR (type)
+ && type->name () != NULL)
+ show = 0;
+ }
+
+ c_print_type (type, varstring, stream, show, level, flags);
+ }
};
+/* Single instance of the OpenCL language class. */
+
+static opencl_language opencl_language_defn;
+
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); \
+ types[opencl_primitive_type_##TYPE##2]->set_name (OCL_STRING(TYPE ## 2)); \
+ types[opencl_primitive_type_##TYPE##3] \
+ = init_vector_type (types[opencl_primitive_type_##TYPE], 3); \
+ types[opencl_primitive_type_##TYPE##3]->set_name (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); \
+ types[opencl_primitive_type_##TYPE##4]->set_name (OCL_STRING(TYPE ## 4)); \
+ types[opencl_primitive_type_##TYPE##8] \
+ = init_vector_type (types[opencl_primitive_type_##TYPE], 8); \
+ types[opencl_primitive_type_##TYPE##8]->set_name (OCL_STRING(TYPE ## 8)); \
+ types[opencl_primitive_type_##TYPE##16] \
+ = init_vector_type (types[opencl_primitive_type_##TYPE], 16); \
+ types[opencl_primitive_type_##TYPE##16]->set_name (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
-_initialize_opencl_language (void)
+_initialize_opencl_language ()
{
opencl_type_data = gdbarch_data_register_post_init (build_opencl_types);
- add_language (&opencl_language_defn);
}
projects / deliverable / binutils-gdb.git / blobdiff