aboutsummaryrefslogtreecommitdiff
path: root/gdb/opencl-lang.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/opencl-lang.c')
-rw-r--r--gdb/opencl-lang.c300
1 files changed, 151 insertions, 149 deletions
diff --git a/gdb/opencl-lang.c b/gdb/opencl-lang.c
index 0052c56..a744cbc 100644
--- a/gdb/opencl-lang.c
+++ b/gdb/opencl-lang.c
@@ -42,13 +42,12 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
/* 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)
- error (_("Invalid OpenCL vector size: %d"), n);
+ error (_ ("Invalid OpenCL vector size: %d"), n);
/* Triple vectors have the size of a quad vector. */
- length = (n == 3) ? el_length * 4 : el_length * n;
+ length = (n == 3) ? el_length * 4 : el_length * n;
- auto filter = [&] (struct type *type)
- {
+ auto filter = [&] (struct type *type) {
LONGEST lowb, highb;
return (type->code () == TYPE_CODE_ARRAY && type->is_vector ()
@@ -56,8 +55,7 @@ lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
&& type->target_type ()->code () == code
&& type->target_type ()->is_unsigned () == flag_unsigned
&& type->target_type ()->length () == el_length
- && type->length () == length
- && highb - lowb + 1 == n);
+ && type->length () == length && highb - lowb + 1 == n);
};
const struct language_defn *lang = language_def (language_opencl);
return language_lookup_primitive_type (lang, gdbarch, filter);
@@ -130,7 +128,7 @@ lval_func_read (struct value *v)
if (type->code () == TYPE_CODE_ARRAY
&& !get_array_bounds (type, &lowb, &highb))
- error (_("Could not determine the vector bounds"));
+ error (_ ("Could not determine the vector bounds"));
/* Assume elsize aligned offset. */
gdb_assert (offset % elsize == 0);
@@ -140,8 +138,7 @@ lval_func_read (struct value *v)
for (i = offset; i < n; i++)
memcpy (value_contents_raw (v).data () + j++ * elsize,
- value_contents (c->val).data () + c->indices[i] * elsize,
- elsize);
+ value_contents (c->val).data () + c->indices[i] * elsize, elsize);
}
static void
@@ -160,7 +157,7 @@ lval_func_write (struct value *v, struct value *fromval)
if (type->code () == TYPE_CODE_ARRAY
&& !get_array_bounds (type, &lowb, &highb))
- error (_("Could not determine the vector bounds"));
+ error (_ ("Could not determine the vector bounds"));
/* Assume elsize aligned offset. */
gdb_assert (offset % elsize == 0);
@@ -181,8 +178,7 @@ lval_func_write (struct value *v, struct value *fromval)
struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
memcpy (value_contents_writeable (from_elm_val).data (),
- value_contents (fromval).data () + j++ * elsize,
- elsize);
+ value_contents (fromval).data () + j++ * elsize, elsize);
value_assign (to_elm_val, from_elm_val);
}
}
@@ -191,13 +187,13 @@ lval_func_write (struct value *v, struct value *fromval)
synthetic pointer. */
static int
-lval_func_check_synthetic_pointer (const struct value *v,
- LONGEST 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. */
- int elsize =
- check_typedef (value_type (c->val))->target_type ()->length () * 8;
+ int elsize
+ = check_typedef (value_type (c->val))->target_type ()->length () * 8;
int startrest = offset % elsize;
int start = offset / elsize;
int endrest = (offset + length) % elsize;
@@ -243,23 +239,22 @@ lval_func_free_closure (struct value *v)
if (c->refc == 0)
{
- value_decref (c->val); /* Decrement the reference counter of the value. */
+ value_decref (
+ c->val); /* Decrement the reference counter of the value. */
xfree (c->indices);
xfree (c);
}
}
-static const struct lval_funcs opencl_value_funcs =
- {
- lval_func_read,
- lval_func_write,
- nullptr,
- NULL, /* indirect */
- NULL, /* coerce_ref */
- lval_func_check_synthetic_pointer,
- lval_func_copy_closure,
- lval_func_free_closure
- };
+static const struct lval_funcs opencl_value_funcs
+ = { lval_func_read,
+ lval_func_write,
+ nullptr,
+ NULL, /* indirect */
+ NULL, /* coerce_ref */
+ lval_func_check_synthetic_pointer,
+ lval_func_copy_closure,
+ lval_func_free_closure };
/* Creates a sub-vector from VAL. The elements are selected by the indices of
an array with the length of N. Supported values for NOSIDE are
@@ -286,10 +281,10 @@ create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
{
/* 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, elm_type->code (),
- elm_type->length (),
- elm_type->is_unsigned (), n);
+ struct type *dst_type
+ = lookup_opencl_vector_type (gdbarch, elm_type->code (),
+ elm_type->length (),
+ elm_type->is_unsigned (), n);
if (dst_type == NULL)
dst_type = init_vector_type (elm_type, n);
@@ -315,9 +310,9 @@ create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
/* Copy src val contents into the destination value. */
for (i = 0; i < n; i++)
memcpy (value_contents_writeable (ret).data ()
- + (i * elm_type->length ()),
+ + (i * elm_type->length ()),
value_contents (val).data ()
- + (indices[i] * elm_type->length ()),
+ + (indices[i] * elm_type->length ()),
elm_type->length ());
}
}
@@ -338,7 +333,7 @@ opencl_component_ref (struct expression *exp, struct value *val,
int dst_len;
if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
- error (_("Could not determine the vector bounds"));
+ error (_ ("Could not determine the vector bounds"));
src_len = highb - lowb + 1;
@@ -346,9 +341,9 @@ opencl_component_ref (struct expression *exp, struct value *val,
valid OpenCL vector size (2, 3, 4, 8, 16). */
if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
&& src_len != 16)
- error (_("Invalid OpenCL vector size"));
+ error (_ ("Invalid OpenCL vector size"));
- if (strcmp (comps, "lo") == 0 )
+ if (strcmp (comps, "lo") == 0)
{
dst_len = (src_len == 3) ? 2 : src_len / 2;
@@ -367,21 +362,23 @@ opencl_component_ref (struct expression *exp, struct value *val,
dst_len = (src_len == 3) ? 2 : src_len / 2;
for (i = 0; i < dst_len; i++)
- indices[i] = i*2;
+ indices[i] = i * 2;
}
else if (strcmp (comps, "odd") == 0)
{
dst_len = (src_len == 3) ? 2 : src_len / 2;
for (i = 0; i < dst_len; i++)
- indices[i] = i*2+1;
+ indices[i] = i * 2 + 1;
}
else if (strncasecmp (comps, "s", 1) == 0)
{
-#define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
- C-'0' : ((C >= 'A' && C <= 'F') ? \
- C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
- C-'a'+10 : -1)))
+#define HEXCHAR_TO_INT(C) \
+ ((C >= '0' && C <= '9') \
+ ? C - '0' \
+ : ((C >= 'A' && C <= 'F') \
+ ? C - 'A' + 10 \
+ : ((C >= 'a' && C <= 'f') ? C - 'a' + 10 : -1)))
dst_len = strlen (comps);
/* Skip the s/S-prefix. */
@@ -389,11 +386,11 @@ opencl_component_ref (struct expression *exp, struct value *val,
for (i = 0; i < dst_len; i++)
{
- indices[i] = HEXCHAR_TO_INT(comps[i+1]);
+ indices[i] = HEXCHAR_TO_INT (comps[i + 1]);
/* Check if the requested component is invalid or exceeds
the vector. */
if (indices[i] < 0 || indices[i] >= src_len)
- error (_("Invalid OpenCL vector component accessor %s"), comps);
+ error (_ ("Invalid OpenCL vector component accessor %s"), comps);
}
}
else
@@ -404,27 +401,29 @@ opencl_component_ref (struct expression *exp, struct value *val,
{
/* x, y, z, w */
switch (comps[i])
- {
- case 'x':
- indices[i] = 0;
- break;
- case 'y':
- indices[i] = 1;
- break;
- case 'z':
- if (src_len < 3)
- error (_("Invalid OpenCL vector component accessor %s"), comps);
- indices[i] = 2;
- break;
- case 'w':
- if (src_len < 4)
- error (_("Invalid OpenCL vector component accessor %s"), comps);
- indices[i] = 3;
- break;
- default:
- error (_("Invalid OpenCL vector component accessor %s"), comps);
- break;
- }
+ {
+ case 'x':
+ indices[i] = 0;
+ break;
+ case 'y':
+ indices[i] = 1;
+ break;
+ case 'z':
+ if (src_len < 3)
+ error (_ ("Invalid OpenCL vector component accessor %s"),
+ comps);
+ indices[i] = 2;
+ break;
+ case 'w':
+ if (src_len < 4)
+ error (_ ("Invalid OpenCL vector component accessor %s"),
+ comps);
+ indices[i] = 3;
+ break;
+ default:
+ error (_ ("Invalid OpenCL vector component accessor %s"), comps);
+ break;
+ }
}
}
@@ -432,7 +431,7 @@ opencl_component_ref (struct expression *exp, struct value *val,
result in a valid length (1, 2, 3, 4, 8, 16). */
if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
&& dst_len != 8 && dst_len != 16)
- error (_("Invalid OpenCL vector component accessor %s"), comps);
+ error (_ ("Invalid OpenCL vector component accessor %s"), comps);
v = create_value (exp->gdbarch, val, noside, indices, dst_len);
@@ -443,8 +442,7 @@ opencl_component_ref (struct expression *exp, struct value *val,
struct value *
opencl_logical_not (struct type *expect_type, struct expression *exp,
- enum noside noside, enum exp_opcode op,
- struct value *arg)
+ enum noside noside, enum exp_opcode op, struct value *arg)
{
struct type *type = check_typedef (value_type (arg));
struct type *rettype;
@@ -457,13 +455,13 @@ opencl_logical_not (struct type *expect_type, struct expression *exp,
int i;
if (!get_array_bounds (type, &lowb, &highb))
- error (_("Could not determine the vector bounds"));
+ error (_ ("Could not determine the vector bounds"));
/* Determine the resulting type of the operation and allocate the
value. */
- rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
- eltype->length (), 0,
- highb - lowb + 1);
+ rettype
+ = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
+ eltype->length (), 0, highb - lowb + 1);
ret = allocate_value (rettype);
for (i = 0; i < highb - lowb + 1; i++)
@@ -520,7 +518,7 @@ scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
ret = !value_logical_not (val1) || !value_logical_not (val2);
break;
default:
- error (_("Attempt to perform an unsupported operation"));
+ error (_ ("Attempt to perform an unsupported operation"));
break;
}
return ret;
@@ -544,26 +542,26 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
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"));
+ error (_ ("Vector operations are not supported on scalar types"));
eltype1 = check_typedef (type1->target_type ());
eltype2 = check_typedef (type2->target_type ());
- if (!get_array_bounds (type1,&lowb1, &highb1)
+ if (!get_array_bounds (type1, &lowb1, &highb1)
|| !get_array_bounds (type2, &lowb2, &highb2))
- error (_("Could not determine the vector bounds"));
+ error (_ ("Could not determine the vector bounds"));
/* Check whether the vector types are compatible. */
if (eltype1->code () != eltype2->code ()
|| eltype1->length () != eltype2->length ()
- || eltype1->is_unsigned () != eltype2->is_unsigned ()
- || lowb1 != lowb2 || highb1 != highb2)
- error (_("Cannot perform operation on vectors with different types"));
+ || eltype1->is_unsigned () != eltype2->is_unsigned () || lowb1 != lowb2
+ || highb1 != highb2)
+ error (_ ("Cannot perform operation on vectors with different types"));
/* Determine the resulting type of the operation and allocate the value. */
- rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
- eltype1->length (), 0,
- highb1 - lowb1 + 1);
+ rettype
+ = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
+ eltype1->length (), 0, highb1 - lowb1 + 1);
ret = allocate_value (rettype);
for (i = 0; i < highb1 - lowb1 + 1; i++)
@@ -572,11 +570,13 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
return 0 if the specified relation is false and -1 (i.e. all bits set)
if the specified relation is true. */
int tmp = scalar_relop (value_subscript (val1, i),
- value_subscript (val2, i), op) ? -1 : 0;
+ value_subscript (val2, i), op)
+ ? -1
+ : 0;
memset ((value_contents_writeable (ret).data ()
+ i * eltype1->length ()),
tmp, eltype1->length ());
- }
+ }
return ret;
}
@@ -606,7 +606,7 @@ opencl_value_cast (struct type *type, struct value *arg)
code2 = check_typedef (value_type (arg))->code ();
if (code2 == TYPE_CODE_REF)
- code2 = check_typedef (value_type (coerce_ref(arg)))->code ();
+ 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
@@ -637,22 +637,20 @@ opencl_value_cast (struct type *type, struct value *arg)
struct value *
opencl_relop (struct type *expect_type, struct expression *exp,
- enum noside noside, enum exp_opcode op,
- struct value *arg1, struct value *arg2)
+ enum noside noside, enum exp_opcode op, struct value *arg1,
+ struct value *arg2)
{
struct value *val;
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
- && type1->is_vector ());
- int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY
- && type2->is_vector ());
+ int t1_is_vec = (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ());
+ int t2_is_vec = (type2->code () == TYPE_CODE_ARRAY && type2->is_vector ());
if (!t1_is_vec && !t2_is_vec)
{
int tmp = scalar_relop (arg1, arg2, op);
- struct type *type =
- language_bool_type (exp->language_defn, exp->gdbarch);
+ struct type *type
+ = language_bool_type (exp->language_defn, exp->gdbarch);
val = value_from_longest (type, tmp);
}
@@ -667,7 +665,7 @@ opencl_relop (struct type *expect_type, struct expression *exp,
struct type *t = t1_is_vec ? type2 : type1;
if (t->code () != TYPE_CODE_FLT && !is_integral_type (t))
- error (_("Argument to operation not a number or boolean."));
+ error (_ ("Argument to operation not a number or boolean."));
*v = opencl_value_cast (t1_is_vec ? type1 : type2, *v);
val = vector_relop (exp, arg1, arg2, op);
@@ -680,8 +678,8 @@ opencl_relop (struct type *expect_type, struct expression *exp,
struct value *
eval_opencl_assign (struct type *expect_type, struct expression *exp,
- enum noside noside, enum exp_opcode op,
- struct value *arg1, struct value *arg2)
+ enum noside noside, enum exp_opcode op, struct value *arg1,
+ struct value *arg2)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
@@ -710,9 +708,9 @@ opencl_structop_operation::evaluate (struct type *expect_type,
noside);
else
{
- struct value *v = value_struct_elt (&arg1, {},
- std::get<1> (m_storage).c_str (),
- NULL, "structure");
+ struct value *v
+ = value_struct_elt (&arg1, {}, std::get<1> (m_storage).c_str (), NULL,
+ "structure");
if (noside == EVAL_AVOID_SIDE_EFFECTS)
v = value_zero (value_type (v), VALUE_LVAL (v));
@@ -786,10 +784,8 @@ opencl_ternop_cond_operation::evaluate (struct type *expect_type,
arg3 = std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
type2 = check_typedef (value_type (arg2));
type3 = check_typedef (value_type (arg3));
- t2_is_vec
- = type2->code () == TYPE_CODE_ARRAY && type2->is_vector ();
- t3_is_vec
- = type3->code () == TYPE_CODE_ARRAY && type3->is_vector ();
+ t2_is_vec = type2->code () == TYPE_CODE_ARRAY && type2->is_vector ();
+ t3_is_vec = type3->code () == TYPE_CODE_ARRAY && type3->is_vector ();
/* Widen the scalar operand to a vector if necessary. */
if (t2_is_vec || !t3_is_vec)
@@ -805,7 +801,7 @@ opencl_ternop_cond_operation::evaluate (struct type *expect_type,
else if (!t2_is_vec || !t3_is_vec)
{
/* Throw an error if arg2 or arg3 aren't vectors. */
- error (_("\
+ error (_ ("\
Cannot perform conditional operation on incompatible types"));
}
@@ -815,31 +811,32 @@ Cannot perform conditional operation on incompatible types"));
if (!get_array_bounds (type1, &lowb1, &highb1)
|| !get_array_bounds (type2, &lowb2, &highb2)
|| !get_array_bounds (type3, &lowb3, &highb3))
- error (_("Could not determine the vector bounds"));
+ error (_ ("Could not determine the vector bounds"));
/* Throw an error if the types of arg2 or arg3 are incompatible. */
if (eltype2->code () != eltype3->code ()
|| eltype2->length () != eltype3->length ()
|| eltype2->is_unsigned () != eltype3->is_unsigned ()
|| lowb2 != lowb3 || highb2 != highb3)
- error (_("\
+ error (_ ("\
Cannot perform operation on vectors with different types"));
/* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
- if (lowb1 != lowb2 || lowb1 != lowb3
- || highb1 != highb2 || highb1 != highb3)
- error (_("\
+ if (lowb1 != lowb2 || lowb1 != lowb3 || highb1 != highb2
+ || highb1 != highb3)
+ error (_ ("\
Cannot perform conditional operation on vectors with different sizes"));
ret = allocate_value (type2);
for (i = 0; i < highb1 - lowb1 + 1; i++)
{
- tmp = value_logical_not (value_subscript (arg1, i)) ?
- value_subscript (arg3, i) : value_subscript (arg2, i);
- memcpy (value_contents_writeable (ret).data () +
- i * eltype2->length (), value_contents_all (tmp).data (),
- eltype2->length ());
+ tmp = value_logical_not (value_subscript (arg1, i))
+ ? value_subscript (arg3, i)
+ : value_subscript (arg2, i);
+ memcpy (value_contents_writeable (ret).data ()
+ + i * eltype2->length (),
+ value_contents_all (tmp).data (), eltype2->length ());
}
return ret;
@@ -860,26 +857,26 @@ Cannot perform conditional operation on vectors with different sizes"));
class opencl_language : public language_defn
{
public:
+
opencl_language ()
: language_defn (language_opencl)
- { /* Nothing. */ }
+ { /* Nothing. */
+ }
/* See language.h. */
- const char *name () const override
- { return "opencl"; }
+ const char *name () const override { return "opencl"; }
/* See language.h. */
- const char *natural_name () const override
- { return "OpenCL C"; }
+ const char *natural_name () const override { return "OpenCL C"; }
/* See language.h. */
void language_arch_info (struct gdbarch *gdbarch,
struct language_arch_info *lai) const override
{
/* Helper function to allow shorter lines below. */
- auto add = [&] (struct type * t) -> struct type *
+ auto add = [&](struct type * t) -> struct type *
{
lai->add_primitive_type (t);
return t;
@@ -890,23 +887,23 @@ public:
/* This macro allocates and assigns the type struct pointers
for the vector types. */
-#define BUILD_OCL_VTYPES(TYPE, ELEMENT_TYPE) \
- do \
- { \
- struct type *tmp; \
- tmp = add (init_vector_type (ELEMENT_TYPE, 2)); \
- tmp->set_name (OCL_STRING(TYPE ## 2)); \
- tmp = add (init_vector_type (ELEMENT_TYPE, 3)); \
- tmp->set_name (OCL_STRING(TYPE ## 3)); \
- tmp->set_length (4 * (ELEMENT_TYPE)->length ()); \
- tmp = add (init_vector_type (ELEMENT_TYPE, 4)); \
- tmp->set_name (OCL_STRING(TYPE ## 4)); \
- tmp = add (init_vector_type (ELEMENT_TYPE, 8)); \
- tmp->set_name (OCL_STRING(TYPE ## 8)); \
- tmp = init_vector_type (ELEMENT_TYPE, 16); \
- tmp->set_name (OCL_STRING(TYPE ## 16)); \
- } \
- while (false)
+#define BUILD_OCL_VTYPES(TYPE, ELEMENT_TYPE) \
+ do \
+ { \
+ struct type *tmp; \
+ tmp = add (init_vector_type (ELEMENT_TYPE, 2)); \
+ tmp->set_name (OCL_STRING (TYPE##2)); \
+ tmp = add (init_vector_type (ELEMENT_TYPE, 3)); \
+ tmp->set_name (OCL_STRING (TYPE##3)); \
+ tmp->set_length (4 * (ELEMENT_TYPE)->length ()); \
+ tmp = add (init_vector_type (ELEMENT_TYPE, 4)); \
+ tmp->set_name (OCL_STRING (TYPE##4)); \
+ tmp = add (init_vector_type (ELEMENT_TYPE, 8)); \
+ tmp->set_name (OCL_STRING (TYPE##8)); \
+ tmp = init_vector_type (ELEMENT_TYPE, 16); \
+ tmp->set_name (OCL_STRING (TYPE##16)); \
+ } \
+ while (false)
struct type *el_type, *char_type, *int_type;
@@ -926,11 +923,14 @@ public:
BUILD_OCL_VTYPES (long, el_type);
el_type = add (arch_integer_type (gdbarch, 64, 1, "ulong"));
BUILD_OCL_VTYPES (ulong, el_type);
- el_type = add (arch_float_type (gdbarch, 16, "half", floatformats_ieee_half));
+ el_type
+ = add (arch_float_type (gdbarch, 16, "half", floatformats_ieee_half));
BUILD_OCL_VTYPES (half, el_type);
- el_type = add (arch_float_type (gdbarch, 32, "float", floatformats_ieee_single));
+ el_type
+ = add (arch_float_type (gdbarch, 32, "float", floatformats_ieee_single));
BUILD_OCL_VTYPES (float, el_type);
- el_type = add (arch_float_type (gdbarch, 64, "double", floatformats_ieee_double));
+ el_type = add (arch_float_type (gdbarch, 64, "double",
+ floatformats_ieee_double));
BUILD_OCL_VTYPES (double, el_type);
add (arch_boolean_type (gdbarch, 8, 1, "bool"));
@@ -939,9 +939,12 @@ public:
add (arch_integer_type (gdbarch, 32, 1, "unsigned int"));
add (arch_integer_type (gdbarch, 64, 1, "unsigned long"));
add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t"));
- add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t"));
- add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t"));
- add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t"));
+ add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0,
+ "ptrdiff_t"));
+ add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0,
+ "intptr_t"));
+ add (arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1,
+ "uintptr_t"));
add (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void"));
/* Type of elements of strings. */
@@ -953,10 +956,7 @@ public:
/* See language.h. */
- bool can_print_type_offsets () const override
- {
- return true;
- }
+ bool can_print_type_offsets () const override { return true; }
/* See language.h. */
@@ -981,7 +981,9 @@ public:
/* See language.h. */
enum macro_expansion macro_expansion () const override
- { return macro_expansion_c; }
+ {
+ return macro_expansion_c;
+ }
};
/* Single instance of the OpenCL language class. */
generated by cgit v1.1 at 2024-11-16 23:37:17 +0000