/* Declare the function shape NAME, pointing it to an instance
of class <NAME>_def. */
-#define SHAPE(NAME) \
- static CONSTEXPR const NAME##_def NAME##_obj; \
- namespace shapes { const function_shape *const NAME = &NAME##_obj; }
+#define SHAPE(NAME) \
+ static CONSTEXPR const NAME##_def NAME##_obj; \
+ namespace shapes { const function_shape *const NAME = &NAME##_obj; } \
+ extern int __require_trailing_semicolon ATTRIBUTE_UNUSED
/* Base class for functions that are not overloaded. */
struct nonoverloaded_base : public function_shape
/* Specializations for 2-bit and 4-bit indices. */
using luti2_def = luti_base<2>;
-SHAPE (luti2)
+SHAPE (luti2);
using luti4_def = luti_base<4>;
-SHAPE (luti4)
+SHAPE (luti4);
/* sv<t0>x<g>_t svfoo_t0_g(uint64_t, svuint8_t, uint64_t)
return res;
}
};
-SHAPE (mmla)
+SHAPE (mmla);
/* Base class for prefetch_gather_index and prefetch_gather_offset,
which differ only in the units of the displacement. */
build_all (b, "b,b,d", group, MODE_u64base_u64index);
}
};
-SHAPE (adr_index)
+SHAPE (adr_index);
/* sv<m0>_t svfoo[_m0base]_[m1]offset(sv<m0>_t, sv<m1>_t).
build_all (b, "b,b,d", group, MODE_u64base_u64offset);
}
};
-SHAPE (adr_offset)
+SHAPE (adr_offset);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t)
return r.resolve_uniform (2);
}
};
-SHAPE (binary)
+SHAPE (binary);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:int>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, <t0:int>_t).
return r.finish_opt_n_resolution (i + 1, i, type, TYPE_signed);
}
};
-SHAPE (binary_int_opt_n)
+SHAPE (binary_int_opt_n);
/* Like binary_int_opt_n for single vectors. For tuples:
: r.finish_opt_single_resolution (i + 1, i, type, TYPE_signed));
}
};
-SHAPE (binary_int_opt_single_n)
+SHAPE (binary_int_opt_single_n);
/* sv<t0>_t svfoo_<t0>(sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_lane_index (2, 1);
}
};
-SHAPE (binary_lane)
+SHAPE (binary_lane);
/* sv<t0>_t svfoo[_t0](sv<t0:half>_t, sv<t0:half>_t, uint64_t).
return c.require_immediate_lane_index (2, 1);
}
};
-SHAPE (binary_long_lane)
+SHAPE (binary_long_lane);
/* sv<t0>_t svfoo[_t0](sv<t0:half>_t, sv<t0:half>_t)
sv<t0>_t svfoo[_n_t0](sv<t0:half>_t, <t0:half>_t). */
r.SAME_SIZE, result_type);
}
};
-SHAPE (binary_long_opt_n)
+SHAPE (binary_long_opt_n);
/* sv<t0>_t svfoo[_n_t0](sv<t0>_t, <t0>_t).
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (binary_n)
+SHAPE (binary_n);
/* sv<t0:half>_t svfoo[_t0](sv<t0>_t, sv<t0>_t)
sv<t0:half>_t svfoo[_n_t0](sv<t0>_t, <t0>_t)
return r.resolve_uniform_opt_n (2);
}
};
-SHAPE (binary_narrowb_opt_n)
+SHAPE (binary_narrowb_opt_n);
/* sv<t0:half>_t svfoo[_t0](sv<t0:half>_t, sv<t0>_t, sv<t0>_t)
sv<t0:half>_t svfoo[_n_t0](sv<t0:half>_t, sv<t0>_t, <t0>_t)
return r.finish_opt_n_resolution (i + 2, i + 1, type);
}
};
-SHAPE (binary_narrowt_opt_n)
+SHAPE (binary_narrowt_opt_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, <t0>_t)
return r.resolve_uniform_opt_n (2);
}
};
-SHAPE (binary_opt_n)
+SHAPE (binary_opt_n);
/* Like binary_opt_n for single vectors. For tuples:
: r.finish_opt_single_resolution (i + 1, i, type));
}
};
-SHAPE (binary_opt_single_n)
+SHAPE (binary_opt_single_n);
/* svbool_t svfoo(svbool_t, svbool_t). */
struct binary_pred_def : public nonoverloaded_base
build_all (b, "v0,v0,v0", group, MODE_none);
}
};
-SHAPE (binary_pred)
+SHAPE (binary_pred);
/* sv<t0>_t svfoo[_<t0>](sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_either_or (2, 90, 270);
}
};
-SHAPE (binary_rotate)
+SHAPE (binary_rotate);
/* sv<t0>_t svfoo_t0(<t0>_t, <t0>_t)
build_all (b, "v0,s0,s0", group, MODE_none);
}
};
-SHAPE (binary_scalar)
+SHAPE (binary_scalar);
/* sv<t0>x<g>_t svfoo[_single_t0_g](sv<t0>x<g>_t, sv<t0>_t). */
struct binary_single_def : public overloaded_base<0>
return r.resolve_to (MODE_single, type);
}
};
-SHAPE (binary_single)
+SHAPE (binary_single);
/* sv<t0:uint>_t svfoo[_t0](sv<t0>_t, sv<t0>_t).
return r.resolve_uniform (2);
}
};
-SHAPE (binary_to_uint)
+SHAPE (binary_to_uint);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:uint>_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (binary_uint)
+SHAPE (binary_uint);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, <t0:uint>_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (binary_uint_n)
+SHAPE (binary_uint_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:uint>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, <t0:uint>_t)
return r.finish_opt_n_resolution (i + 1, i, type, TYPE_unsigned);
}
};
-SHAPE (binary_uint_opt_n)
+SHAPE (binary_uint_opt_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, uint64_t).
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (binary_uint64_n)
+SHAPE (binary_uint64_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svuint64_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, uint64_t)
return r.finish_opt_n_resolution (i + 1, i, type, TYPE_unsigned, 64);
}
};
-SHAPE (binary_uint64_opt_n)
+SHAPE (binary_uint64_opt_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:half>_t). */
struct binary_wide_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (binary_wide)
+SHAPE (binary_wide);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:half>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, <t0:half>_t). */
r.HALF_SIZE);
}
};
-SHAPE (binary_wide_opt_n)
+SHAPE (binary_wide_opt_n);
/* void svfoo_t0[_t1]_g(uint64_t, svbool_t, svbool_t, sv<t1>x<g>_t,
sv<t1:int>x<g>_t)
build_all (b, "_,su64,vp,vp,t1,ts1", group, MODE_none);
}
};
-SHAPE (binary_za_int_m)
+SHAPE (binary_za_int_m);
/* void svfoo_t0[_t1]_g(uint64_t, svbool_t, svbool_t, sv<t1>x<g>_t,
sv<t1>x<g>_t)
build_all (b, "_,su64,vp,vp,t1,t1", group, MODE_none);
}
};
-SHAPE (binary_za_m)
+SHAPE (binary_za_m);
/* void svfoo_lane_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1>_t, uint64_t)
{
constexpr binary_za_slice_lane_def () : binary_za_slice_lane_base<> (1) {}
};
-SHAPE (binary_za_slice_lane)
+SHAPE (binary_za_slice_lane);
/* void svfoo_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1:int>x<g>_t)
void svfoo[_single]_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1:int>_t).
build_all (b, "_,su32,t1,vs1", group, MODE_single);
}
};
-SHAPE (binary_za_slice_int_opt_single)
+SHAPE (binary_za_slice_int_opt_single);
/* void svfoo_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1>x<g>_t)
void svfoo[_single]_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1>_t)
build_all (b, "_,su32,t1,v1", group, MODE_single);
}
};
-SHAPE (binary_za_slice_opt_single)
+SHAPE (binary_za_slice_opt_single);
/* void svfoo_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1:uint>x<g>_t)
void svfoo[_single]_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1:uint>_t)
build_all (b, "_,su32,t1,vu1", group, MODE_single);
}
};
-SHAPE (binary_za_slice_uint_opt_single)
+SHAPE (binary_za_slice_uint_opt_single);
/* void svfoo_t0[_t1]_g(uint64_t, svbool_t, svbool_t, sv<t1>x<g>_t,
sv<t1:uint>x<g>_t)
build_all (b, "_,su64,vp,vp,t1,tu1", group, MODE_none);
}
};
-SHAPE (binary_za_uint_m)
+SHAPE (binary_za_uint_m);
/* sv<t0>x<g>_t svfoo[_t0_t1_g](sv<t0>x<g>_t, sv<t0>x<g>_t). */
struct binaryxn_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (binaryxn)
+SHAPE (binaryxn);
/* bool svfoo(). */
struct bool_inherent_def : public nonoverloaded_base
build_all (b, "sp", group, MODE_none);
}
};
-SHAPE (bool_inherent)
+SHAPE (bool_inherent);
/* Either:
return r.resolve_to (mode, type);
}
};
-SHAPE (clamp)
+SHAPE (clamp);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t)
<t0>_t svfoo[_n_t0](<t0>_t, sv<t0>_t). */
}
}
};
-SHAPE (clast)
+SHAPE (clast);
/* svbool_t svfoo[_t0](sv<t0>_t, sv<t0>_t). */
struct compare_def : public overloaded_base<0>
return r.resolve_uniform (2);
}
};
-SHAPE (compare)
+SHAPE (compare);
/* svbool_t svfoo[_t0](sv<t0>_t, sv<t0>_t)
svbool_t svfoo[_n_t0](sv<t0>_t, <t0>_t)
return r.resolve_uniform_opt_n (2);
}
};
-SHAPE (compare_opt_n)
+SHAPE (compare_opt_n);
/* svbool_t svfoo[_t0](const <t0>_t *, const <t0>_t *). */
struct compare_ptr_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (compare_ptr)
+SHAPE (compare_ptr);
/* svboolx<g>_t svfoo_t0[_t1]_g(<t1>_t, <t1>_t)
NUM_TYPE_SUFFIXES, r.group_suffix_id);
}
};
-SHAPE (compare_scalar)
+SHAPE (compare_scalar);
/* svcount_t svfoo_t0[_t1](<t1>_t, <t1>_t, uint64_t)
return c.require_immediate_either_or (2, 2, 4);
}
};
-SHAPE (compare_scalar_count)
+SHAPE (compare_scalar_count);
/* svbool_t svfoo[_t0](sv<t0>_t, svint64_t) (for signed t0)
svbool_t svfoo[_n_t0](sv<t0>_t, int64_t) (for signed t0)
return r.finish_opt_n_resolution (i + 1, i, type, r.SAME_TYPE_CLASS, 64);
}
};
-SHAPE (compare_wide_opt_n)
+SHAPE (compare_wide_opt_n);
/* uint64_t svfoo(). */
struct count_inherent_def : public nonoverloaded_base
build_all (b, "su64", group, MODE_none);
}
};
-SHAPE (count_inherent)
+SHAPE (count_inherent);
/* uint64_t svfoo(enum svpattern). */
struct count_pat_def : public nonoverloaded_base
build_all (b, "su64,epattern", group, MODE_none);
}
};
-SHAPE (count_pat)
+SHAPE (count_pat);
/* uint64_t svfoo(svbool_t). */
struct count_pred_def : public nonoverloaded_base
build_all (b, "su64,vp", group, MODE_none);
}
};
-SHAPE (count_pred)
+SHAPE (count_pred);
/* uint64_t svfoo_t0(sv<t0>_t, uint64_t)
return c.require_immediate_either_or (1, 2, 4);
}
};
-SHAPE (count_pred_c)
+SHAPE (count_pred_c);
/* uint64_t svfoo[_t0](sv<t0>_t). */
struct count_vector_def : public overloaded_base<0>
return r.resolve_uniform (1);
}
};
-SHAPE (count_vector)
+SHAPE (count_vector);
/* sv<t0>xN_t svfoo[_t0](sv<t0>_t, ..., sv<t0>_t)
return r.resolve_uniform (r.vectors_per_tuple ());
}
};
-SHAPE (create)
+SHAPE (create);
/* void svfoo_lane_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1:int>_t, uint64_t)
build_all (b, "_,su32,t1,vs1,su64", group, MODE_none);
}
};
-SHAPE (dot_za_slice_int_lane)
+SHAPE (dot_za_slice_int_lane);
/* void svfoo_lane_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1>_t, uint64_t)
{
constexpr dot_za_slice_lane_def () : binary_za_slice_lane_base<> (0) {}
};
-SHAPE (dot_za_slice_lane)
+SHAPE (dot_za_slice_lane);
/* void svvdott_lane_za32[_mf8]_vg1x4_fpm (uint32_t slice, svmfloat8x2_t zn,
svmfloat8_t zm, uint64_t imm_idx,
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (dot_half_za_slice_lane)
+SHAPE (dot_half_za_slice_lane);
/* void svfoo_lane_t0[_t1]_g(uint32_t, sv<t1>x<g>_t, sv<t1:uint>_t, uint64_t)
build_all (b, "_,su32,t1,vu1,su64", group, MODE_none);
}
};
-SHAPE (dot_za_slice_uint_lane)
+SHAPE (dot_za_slice_uint_lane);
/* sv<t0>_t svfoo[_n]_t0(<t0>_t, ..., <t0>_t)
gcc_unreachable ();
}
};
-SHAPE (dupq)
+SHAPE (dupq);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_range (2, 0, 256 / bytes - 1);
}
};
-SHAPE (ext)
+SHAPE (ext);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_range (2, 0, 16 / bytes - 1);
}
};
-SHAPE (extq)
+SHAPE (extq);
/* svboolx<g>_t svfoo_t0_g(sv<t0>_t, sv<t0>_t, uint32_t). */
struct extract_pred_def : public nonoverloaded_base
return c.require_immediate_range (1, 0, 4 / size - 1);
}
};
-SHAPE (extract_pred)
+SHAPE (extract_pred);
/* <t0>_t svfoo[_t0](<t0>_t, sv<t0>_t). */
struct fold_left_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (fold_left)
+SHAPE (fold_left);
/* sv<t0>_t svfoo[_t0](sv<t0>xN_t, uint64_t)
return c.require_immediate_range (1, 0, nvectors - 1);
}
};
-SHAPE (get)
+SHAPE (get);
/* <t0>xN_t svfoo[_t0](sv<t0>_t). */
struct get_neonq_def : public overloaded_base<0>
return r.resolve_unary ();
}
};
-SHAPE (get_neonq)
+SHAPE (get_neonq);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, <t0>xN_t). */
struct set_neonq_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (set_neonq)
+SHAPE (set_neonq);
/* sv<t0>_t svfoo[_t0](<t0>xN_t). */
struct dup_neonq_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (dup_neonq)
+SHAPE (dup_neonq);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, uint64_t)
<t0>_t svfoo[_n_t0](<t0>_t, uint64_t)
build_all (b, "s0,s0,su64", group, MODE_n);
}
};
-SHAPE (inc_dec)
+SHAPE (inc_dec);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, enum svpattern, uint64_t)
<t0>_t svfoo[_n_t0](<t0>_t, enum svpattern, uint64_t)
build_all (b, "s0,s0,epattern,su64", group, MODE_n);
}
};
-SHAPE (inc_dec_pat)
+SHAPE (inc_dec_pat);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svbool_t). */
struct inc_dec_pred_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (inc_dec_pred)
+SHAPE (inc_dec_pred);
/* <t0>_t svfoo[_n_t0]_t1(<t0>_t, svbool_t)
return r.resolve_to (r.mode_suffix_id, type, r.type_suffix_ids[1]);
}
};
-SHAPE (inc_dec_pred_scalar)
+SHAPE (inc_dec_pred_scalar);
/* sv<t0>[xN]_t svfoo_t0(). */
struct inherent_def : public nonoverloaded_base
build_all (b, "t0", group, MODE_none);
}
};
-SHAPE (inherent)
+SHAPE (inherent);
/* svbool_t svfoo[_b](). */
struct inherent_b_def : public overloaded_base<0>
gcc_unreachable ();
}
};
-SHAPE (inherent_b)
+SHAPE (inherent_b);
/* void svfoo_t0(). */
struct inherent_za_def : public nonoverloaded_base
build_all (b, "_", group, MODE_none);
}
};
-SHAPE (inherent_za)
+SHAPE (inherent_za);
/* void svfoo_t0(uint64_t). */
struct inherent_za_slice_def : public nonoverloaded_base
build_all (b, "_,su32", group, MODE_none);
}
};
-SHAPE (inherent_za_slice)
+SHAPE (inherent_za_slice);
/* void svfoo_zt(uint64_t)
return c.require_immediate_range (0, 0, 0);
}
};
-SHAPE (inherent_zt)
+SHAPE (inherent_zt);
/* void svfoo_t0(uint64_t)
return c.require_immediate_range (0, 0, 255);
}
};
-SHAPE (inherent_mask_za)
+SHAPE (inherent_mask_za);
/* void svfoo_t0(uint32_t, const void *)
void svfoo_vnum_t0(uint32_t, const void *, int64_t)
build_all (b, "_,su32,al,ss64", group, MODE_vnum);
}
};
-SHAPE (ldr_za)
+SHAPE (ldr_za);
/* void svfoo_zt(uint64_t, const void *)
return c.require_immediate_range (0, 0, 0);
}
};
-SHAPE (ldr_zt)
+SHAPE (ldr_zt);
/* sv<t0>[xN]_t svfoo[_t0]_g(const <t0>_t *)
sv<t0>[xN]_t svfoo_vnum[_t0]_g(const <t0>_t *, int64_t). */
build_all (b, "t0,al,ss64", group, MODE_vnum);
}
};
-SHAPE (load)
+SHAPE (load);
/* sv<t0>_t svfoo_t0(const <X>_t *)
sv<t0>_t svfoo_vnum_t0(const <X>_t *, int64_t)
build_all (b, "t0,al,ss64", group, MODE_vnum);
}
};
-SHAPE (load_ext)
+SHAPE (load_ext);
/* sv<t0>_t svfoo_[s32]index_t0(const <X>_t *, svint32_t)
sv<t0>_t svfoo_[s64]index_t0(const <X>_t *, svint64_t)
build_vs_index (b, "t0,b,ss64", group);
}
};
-SHAPE (load_ext_gather_index)
+SHAPE (load_ext_gather_index);
/* sv<t0>_t svfoo_[s64]index_t0(const <X>_t *, svint64_t)
sv<t0>_t svfoo_[u64]index_t0(const <X>_t *, svuint64_t)
build_vs_index (b, "t0,b,ss64", group);
}
};
-SHAPE (load_ext_gather_index_restricted)
+SHAPE (load_ext_gather_index_restricted);
/* sv<t0>_t svfoo_[s32]offset_t0(const <X>_t *, svint32_t)
sv<t0>_t svfoo_[s64]offset_t0(const <X>_t *, svint64_t)
build_vs_offset (b, "t0,b,ss64", group);
}
};
-SHAPE (load_ext_gather_offset)
+SHAPE (load_ext_gather_offset);
/* sv<t0>_t svfoo_[s64]offset_t0(const <X>_t *, svint64_t)
sv<t0>_t svfoo_[u32]offset_t0(const <X>_t *, svuint32_t)
build_vs_offset (b, "t0,b,ss64", group);
}
};
-SHAPE (load_ext_gather_offset_restricted)
+SHAPE (load_ext_gather_offset_restricted);
/* sv<t0>_t svfoo_[s32]index[_t0](const <t0>_t *, svint32_t)
sv<t0>_t svfoo_[s64]index[_t0](const <t0>_t *, svint64_t)
build_sv_offset (b, "t0,al,d", group);
}
};
-SHAPE (load_gather_sv)
+SHAPE (load_gather_sv);
/* sv<t0>_t svfoo_[u32]index[_t0](const <t0>_t *, svuint32_t)
sv<t0>_t svfoo_[u64]index[_t0](const <t0>_t *, svuint64_t)
build_sv_uint_offset (b, "t0,al,d", group);
}
};
-SHAPE (load_gather_sv_restricted)
+SHAPE (load_gather_sv_restricted);
/* sv<t0>_t svfoo[_u32base]_t0(svuint32_t)
sv<t0>_t svfoo[_u64base]_t0(svuint64_t)
gcc_unreachable ();
}
};
-SHAPE (load_gather_vs)
+SHAPE (load_gather_vs);
/* sv<t0>_t svfoo_[s64]index[_t0](const <t0>_t *, svint64_t)
sv<t0>_t svfoo_[u64]index[_t0](const <t0>_t *, svuint64_t). */
build_all (b, "t0,al,d", group, MODE_u64index);
}
};
-SHAPE (load_gather64_sv_index)
+SHAPE (load_gather64_sv_index);
/* sv<t0>_t svfoo_[s64]offset[_t0](const <t0>_t *, svint64_t)
sv<t0>_t svfoo_[u64]offset[_t0](const <t0>_t *, svuint64_t). */
build_all (b, "t0,al,d", group, MODE_u64offset);
}
};
-SHAPE (load_gather64_sv_offset)
+SHAPE (load_gather64_sv_offset);
/* sv<t0>_t svfoo[_u64base]_index_t0(svuint64_t, int64_t). */
struct load_gather64_vs_index_def : public nonoverloaded_base
gcc_unreachable ();
}
};
-SHAPE (load_gather64_vs_index)
+SHAPE (load_gather64_vs_index);
/* sv<t0>_t svfoo[_u64base]_t0(svuint64_t)
gcc_unreachable ();
}
};
-SHAPE (load_gather64_vs_offset)
+SHAPE (load_gather64_vs_offset);
/* sv<t0>_t svfoo[_t0](const <t0>_t *)
build_all (b, "t0,al", group, MODE_none);
}
};
-SHAPE (load_replicate)
+SHAPE (load_replicate);
/* void svfoo_t0(uint64_t, uint32_t, svbool_t, const void *)
void svfoo_vnum_t0(uint64_t, uint32_t, svbool_t, const void *, int64_t)
return c.require_immediate_range (0, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (load_za)
+SHAPE (load_za);
using luti2_lane_zt_def = luti_lane_zt_base<2>;
-SHAPE (luti2_lane_zt)
+SHAPE (luti2_lane_zt);
using luti4_lane_zt_def = luti_lane_zt_base<4>;
-SHAPE (luti4_lane_zt)
+SHAPE (luti4_lane_zt);
using luti4_zt_def = luti_zt_base<4>;
-SHAPE (luti4_zt)
+SHAPE (luti4_zt);
/* svbool_t svfoo(enum svpattern). */
struct pattern_pred_def : public nonoverloaded_base
build_all (b, "vp,epattern", group, MODE_none);
}
};
-SHAPE (pattern_pred)
+SHAPE (pattern_pred);
/* svbool_t svfoo[_t0](sv<t0>_t). */
struct pmov_from_vector_def : public overloaded_base<0>
return r.resolve_uniform (1);
}
};
-SHAPE (pmov_from_vector)
+SHAPE (pmov_from_vector);
/* svbool_t svfoo[_t0](sv<t0>_t, uint64_t)
return c.require_immediate_range (1, 0, bytes - 1);
}
};
-SHAPE (pmov_from_vector_lane)
+SHAPE (pmov_from_vector_lane);
/* sv<t0>_t svfoo_t0(uint64_t)
return false;
}
};
-SHAPE (pmov_to_vector_lane)
+SHAPE (pmov_to_vector_lane);
/* void svfoo(const void *, svprfop)
void svfoo_vnum(const void *, int64_t, svprfop). */
build_all (b, "_,ap,ss64,eprfop", group, MODE_vnum);
}
};
-SHAPE (prefetch)
+SHAPE (prefetch);
/* void svfoo_[s32]index(const void *, svint32_t, svprfop)
void svfoo_[s64]index(const void *, svint64_t, svprfop)
build_vs_index (b, "_,b,ss64,eprfop", group);
}
};
-SHAPE (prefetch_gather_index)
+SHAPE (prefetch_gather_index);
/* void svfoo_[s32]offset(const void *, svint32_t, svprfop)
void svfoo_[s64]offset(const void *, svint64_t, svprfop)
build_vs_offset (b, "_,b,ss64,eprfop", group);
}
};
-SHAPE (prefetch_gather_offset)
+SHAPE (prefetch_gather_offset);
/* bool svfoo(svbool_t). */
struct ptest_def : public nonoverloaded_base
build_all (b, "sp,vp", group, MODE_none);
}
};
-SHAPE (ptest)
+SHAPE (ptest);
/* svbool_t svfoo(). */
struct rdffr_def : public nonoverloaded_base
build_all (b, "vp", group, MODE_none);
}
};
-SHAPE (rdffr)
+SHAPE (rdffr);
/* sv<t1>x<g>_t svfoo_t0_t1_g(uint64_t, uint32_t). */
struct read_za_def : public nonoverloaded_base
return c.require_immediate_range (0, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (read_za)
+SHAPE (read_za);
/* sv<t1>_t svfoo_t0[_t1](uint64_t, uint32_t)
return c.require_immediate_range (1, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (read_za_m)
+SHAPE (read_za_m);
/* sv<t1>x<g>_t svfoo_t0_t1_g(uint32_t). */
struct read_za_slice_def : public nonoverloaded_base
build_all (b, "t1,su32", group, MODE_none);
}
};
-SHAPE (read_za_slice)
+SHAPE (read_za_slice);
/* <t0>_t svfoo[_t0](sv<t0>_t). */
struct reduction_def : public overloaded_base<0>
return r.resolve_uniform (1);
}
};
-SHAPE (reduction)
+SHAPE (reduction);
/* <t0>xN_t svfoo[_t0](sv<t0>_t). */
struct reduction_neonq_def : public overloaded_base<0>
return r.resolve_uniform (1);
}
};
-SHAPE (reduction_neonq)
+SHAPE (reduction_neonq);
/* int64_t svfoo[_t0](sv<t0>_t) (for signed t0)
uint64_t svfoo[_t0](sv<t0>_t) (for unsigned t0)
return r.resolve_uniform (1);
}
};
-SHAPE (reduction_wide)
+SHAPE (reduction_wide);
/* sv<t0>x<g>_t svfoo_t0[_t1_g](sv<t1>x<g>_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (reinterpret)
+SHAPE (reinterpret);
/* sv<t0>_t svfoo_t0(sv<t0>_t, sv<t0>_t, uint32_t). */
struct select_pred_def : public nonoverloaded_base
build_all (b, "v0,v0,vp,su32", group, MODE_none);
}
};
-SHAPE (select_pred)
+SHAPE (select_pred);
/* sv<t0>xN_t svfoo[_t0](sv<t0>xN_t, uint64_t, sv<t0>_t)
return c.require_immediate_range (1, 0, nvectors - 1);
}
};
-SHAPE (set)
+SHAPE (set);
/* void svfoo(). */
struct setffr_def : public nonoverloaded_base
build_all (b, "_", group, MODE_none);
}
};
-SHAPE (setffr)
+SHAPE (setffr);
/* sv<t0>_t svfoo[_n_t0])(sv<t0>_t, uint64_t)
return c.require_immediate_range (1, 0, bits - 1);
}
};
-SHAPE (shift_left_imm)
+SHAPE (shift_left_imm);
/* sv<t0>_t svfoo[_n_t0])(sv<t0:half>_t, uint64_t)
return c.require_immediate_range (1, 0, bits - 1);
}
};
-SHAPE (shift_left_imm_long)
+SHAPE (shift_left_imm_long);
/* sv<t0:uint>_t svfoo[_n_t0])(sv<t0>_t, uint64_t)
build_all (b, "vu0,v0,su64", group, MODE_n);
}
};
-SHAPE (shift_left_imm_to_uint)
+SHAPE (shift_left_imm_to_uint);
/* sv<t0>_t svfoo[_n_t0])(sv<t0>_t, uint64_t)
return c.require_immediate_range (1, 1, bits);
}
};
-SHAPE (shift_right_imm)
+SHAPE (shift_right_imm);
/* sv<t0:half>_t svfoo[_n_t0])(sv<t0>_t, uint64_t)
range [1, sizeof (<t0>_t) * 4]. */
typedef shift_right_imm_narrow_wrapper<binary_imm_narrowb_base<>, 1>
shift_right_imm_narrowb_def;
-SHAPE (shift_right_imm_narrowb)
+SHAPE (shift_right_imm_narrowb);
/* sv<t0:half>_t svfoo[_n_t0])(sv<t0:half>_t, sv<t0>_t, uint64_t)
range [1, sizeof (<t0>_t) * 4]. */
typedef shift_right_imm_narrow_wrapper<binary_imm_narrowt_base<>, 2>
shift_right_imm_narrowt_def;
-SHAPE (shift_right_imm_narrowt)
+SHAPE (shift_right_imm_narrowt);
/* sv<t0:uint:half>_t svfoo[_n_t0])(sv<t0>_t, uint64_t)
binary_imm_narrowb_base_unsigned;
typedef shift_right_imm_narrow_wrapper<binary_imm_narrowb_base_unsigned, 1>
shift_right_imm_narrowb_to_uint_def;
-SHAPE (shift_right_imm_narrowb_to_uint)
+SHAPE (shift_right_imm_narrowb_to_uint);
/* sv<t0:uint:half>_t svfoo[_n_t0])(sv<t0:uint:half>_t, sv<t0>_t, uint64_t)
binary_imm_narrowt_base_unsigned;
typedef shift_right_imm_narrow_wrapper<binary_imm_narrowt_base_unsigned, 2>
shift_right_imm_narrowt_to_uint_def;
-SHAPE (shift_right_imm_narrowt_to_uint)
+SHAPE (shift_right_imm_narrowt_to_uint);
/* sv<t0>_t svfoo[_n_t0])(sv<t0>_t, uint64_t)
return c.require_immediate_range (1, 1, bits);
}
};
-SHAPE (shift_right_imm_narrowxn)
+SHAPE (shift_right_imm_narrowxn);
/* void svfoo[_t0](<X>_t *, sv<t0>[xN]_t)
void svfoo_vnum[_t0](<X>_t *, int64_t, sv<t0>[xN]_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (store)
+SHAPE (store);
/* void svfoo_[s32]index[_t0](<X>_t *, svint32_t, sv<t0>_t)
void svfoo_[s64]index[_t0](<X>_t *, svint64_t, sv<t0>_t)
build_vs_index (b, "_,b,ss64,t0", group);
}
};
-SHAPE (store_scatter_index)
+SHAPE (store_scatter_index);
/* void svfoo_[s64]index[_t0](<X>_t *, svint64_t, sv<t0>_t)
void svfoo_[u64]index[_t0](<X>_t *, svuint64_t, sv<t0>_t)
build_vs_index (b, "_,b,ss64,t0", group);
}
};
-SHAPE (store_scatter_index_restricted)
+SHAPE (store_scatter_index_restricted);
/* void svfoo_[s32]offset[_t0](<X>_t *, svint32_t, sv<t0>_t)
void svfoo_[s64]offset[_t0](<X>_t *, svint64_t, sv<t0>_t)
build_vs_offset (b, "_,b,ss64,t0", group);
}
};
-SHAPE (store_scatter_offset)
+SHAPE (store_scatter_offset);
/* void svfoo_[s64]offset[_t0](<X>_t *, svint64_t, sv<t0>_t)
void svfoo_[u32]offset[_t0](<X>_t *, svuint32_t, sv<t0>_t)
build_vs_offset (b, "_,b,ss64,t0", group);
}
};
-SHAPE (store_scatter_offset_restricted)
+SHAPE (store_scatter_offset_restricted);
/* void svfoo_[s64]index[_t0](<t0>_t *, svint64_t, sv<t0>_t)
void svfoo_[u64]index[_t0](<t0>_t *, svuint64_t, sv<t0>_t)
build_all (b, "_,b,ss64,t0", group, MODE_u64base_index);
}
};
-SHAPE (store_scatter64_index)
+SHAPE (store_scatter64_index);
/* void svfoo_[s64]offset[_t0](<t0>_t *, svint64_t, sv<t0>_t)
void svfoo_[u64]offset[_t0](<t0>_t *, svuint64_t, sv<t0>_t)
build_all (b, "_,b,ss64,t0", group, MODE_u64base_offset);
}
};
-SHAPE (store_scatter64_offset)
+SHAPE (store_scatter64_offset);
/* void svfoo_t0(uint64_t, uint32_t, svbool_t, void *)
void svfoo_vnum_t0(uint64_t, uint32_t, svbool_t, void *, int64_t)
return c.require_immediate_range (0, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (store_za)
+SHAPE (store_za);
/* void svfoo[_t0_g](<X>_t *, sv<t0>x<g>_t)
void svfoo_vnum[_t0_g](<X>_t *, int64_t, sv<t0>x<g>_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (storexn)
+SHAPE (storexn);
/* void svfoo_t0(uint32_t, void *)
void svfoo_vnum_t0(uint32_t, void *, int64_t)
build_all (b, "_,su32,as,ss64", group, MODE_vnum);
}
};
-SHAPE (str_za)
+SHAPE (str_za);
/* void svfoo_zt(uint64_t, void *)
return c.require_immediate_range (0, 0, 0);
}
};
-SHAPE (str_zt)
+SHAPE (str_zt);
/* sv<t0>_t svfoo[_t0](sv<t0>xN_t, sv<t0:uint>_t). */
struct tbl_tuple_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (tbl_tuple)
+SHAPE (tbl_tuple);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svbfloatt16_t, svbfloat16_t). */
struct ternary_bfloat_def
build_all (b, "v0,v0,vB,vB", group, MODE_none);
}
};
-SHAPE (ternary_bfloat)
+SHAPE (ternary_bfloat);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svmfloat8_t, svmfloat8_t). */
struct ternary_mfloat8_def
NUM_TYPE_SUFFIXES, GROUP_none);
}
};
-SHAPE (ternary_mfloat8)
+SHAPE (ternary_mfloat8);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svbfloat16_t, svbfloat16_t, uint64_t)
where the final argument is an integer constant expression in the range
[0, 7]. */
typedef ternary_bfloat_lane_base<1> ternary_bfloat_lane_def;
-SHAPE (ternary_bfloat_lane)
+SHAPE (ternary_bfloat_lane);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svbfloat16_t, svbfloat16_t, uint64_t)
where the final argument is an integer constant expression in the range
[0, 3]. */
typedef ternary_bfloat_lane_base<2> ternary_bfloat_lanex2_def;
-SHAPE (ternary_bfloat_lanex2)
+SHAPE (ternary_bfloat_lanex2);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svmfloat8_t, svmfloat8_t, uint64_t)
NUM_TYPE_SUFFIXES, GROUP_none);
}
};
-SHAPE (ternary_mfloat8_lane)
+SHAPE (ternary_mfloat8_lane);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svmfloat8_t, svmfloat8_t, uint64_t)
gcc_unreachable ();
}
};
-SHAPE (ternary_mfloat8_lane_group_selection)
+SHAPE (ternary_mfloat8_lane_group_selection);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svbfloatt16_t, svbfloat16_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, svbfloat16_t, bfloat16_t). */
build_all (b, "v0,v0,vB,sB", group, MODE_n);
}
};
-SHAPE (ternary_bfloat_opt_n)
+SHAPE (ternary_bfloat_opt_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svmfloatt8_t, svmfloat8_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, svmfloat8_t, bfloat8_t). */
GROUP_none);
}
};
-SHAPE (ternary_mfloat8_opt_n)
+SHAPE (ternary_mfloat8_opt_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:int:quarter>_t, sv<t0:uint:quarter>_t,
uint64_t)
build_all (b, "v0,v0,vqs0,vqu0,su64", group, MODE_none);
}
};
-SHAPE (ternary_intq_uintq_lane)
+SHAPE (ternary_intq_uintq_lane);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:int:quarter>_t, sv<t0:uint:quarter>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, sv<t0:int:quarter>_t,
build_all (b, "v0,v0,vqs0,squ0", group, MODE_n);
}
};
-SHAPE (ternary_intq_uintq_opt_n)
+SHAPE (ternary_intq_uintq_opt_n);
/* svbool_t svfoo[_<t0>](sv<t0>_t, sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_lane_index (3, 2);
}
};
-SHAPE (ternary_lane)
+SHAPE (ternary_lane);
/* svbool_t svfoo[_<t0>](sv<t0>_t, sv<t0>_t, sv<t0>_t, uint64_t, uint64_t)
&& c.require_immediate_one_of (4, 0, 90, 180, 270));
}
};
-SHAPE (ternary_lane_rotate)
+SHAPE (ternary_lane_rotate);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:half>_t, sv<t0:half>_t, uint64_t)
return c.require_immediate_lane_index (3, 2);
}
};
-SHAPE (ternary_long_lane)
+SHAPE (ternary_long_lane);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:half>_t, sv<t0:half>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, sv<t0:half>_t, <t0:half>_t)
build_all (b, "v0,v0,vh0,sh0", group, MODE_n);
}
};
-SHAPE (ternary_long_opt_n)
+SHAPE (ternary_long_opt_n);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t, sv<t0>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, sv<t0>_t, <t0>_t)
return r.resolve_uniform_opt_n (3);
}
};
-SHAPE (ternary_opt_n)
+SHAPE (ternary_opt_n);
/* A choice between:
return r.resolve_to (r.mode_suffix_id, type0, type1);
}
};
-SHAPE (ternary_qq_or_011_lane)
+SHAPE (ternary_qq_or_011_lane);
/* svbool_t svfoo[_<t0>](sv<t0>_t, sv<t0:quarter>_t, sv<t0:quarter>_t,
uint64_t)
&& c.require_immediate_one_of (4, 0, 90, 180, 270));
}
};
-SHAPE (ternary_qq_lane_rotate)
+SHAPE (ternary_qq_lane_rotate);
/* A choice between:
return r.resolve_to (r.mode_suffix_id, type0, type1);
}
};
-SHAPE (ternary_qq_opt_n_or_011)
+SHAPE (ternary_qq_opt_n_or_011);
/* svbool_t svfoo[_<t0>](sv<t0>_t, sv<t0:quarter>_t, sv<t0:quarter>_t,
uint64_t)
return c.require_immediate_one_of (3, 0, 90, 180, 270);
}
};
-SHAPE (ternary_qq_rotate)
+SHAPE (ternary_qq_rotate);
/* svbool_t svfoo[_<t0>](sv<t0>_t, sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_one_of (3, 0, 90, 180, 270);
}
};
-SHAPE (ternary_rotate)
+SHAPE (ternary_rotate);
/* sv<t0>_t svfoo[_n_t0])(sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_range (2, 0, bits - 1);
}
};
-SHAPE (ternary_shift_left_imm)
+SHAPE (ternary_shift_left_imm);
/* sv<t0>_t svfoo[_n_t0])(sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_range (2, 1, bits);
}
};
-SHAPE (ternary_shift_right_imm)
+SHAPE (ternary_shift_right_imm);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0>_t, sv<t0:uint>_t). */
struct ternary_uint_def : public overloaded_base<0>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (ternary_uint)
+SHAPE (ternary_uint);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, svu<t0:uint:quarter>_t,
sv<t0:int:quarter>_t). */
build_all (b, "v0,v0,vqu0,vqs0", group, MODE_none);
}
};
-SHAPE (ternary_uintq_intq)
+SHAPE (ternary_uintq_intq);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:uint:quarter>_t, sv<t0:int:quarter>_t,
uint64_t)
build_all (b, "v0,v0,vqu0,vqs0,su64", group, MODE_none);
}
};
-SHAPE (ternary_uintq_intq_lane)
+SHAPE (ternary_uintq_intq_lane);
/* sv<t0>_t svfoo[_t0](sv<t0>_t, sv<t0:uint:quarter>_t, sv<t0:int:quarter>_t)
sv<t0>_t svfoo[_n_t0](sv<t0>_t, sv<t0:uint:quarter>_t,
build_all (b, "v0,v0,vqu0,sqs0", group, MODE_n);
}
};
-SHAPE (ternary_uintq_intq_opt_n)
+SHAPE (ternary_uintq_intq_opt_n);
/* svbool_t svfoo[_<t0>](sv<t0>_t, sv<t0>_t, uint64_t)
return c.require_immediate_range (2, 0, 7);
}
};
-SHAPE (tmad)
+SHAPE (tmad);
/* sv<t0>_t svfoo[_t0](sv<t0>_t)
return r.resolve_unary ();
}
};
-SHAPE (unary)
+SHAPE (unary);
/* sv<t0>_t svfoo_t0[_t1](sv<t1>_t)
r.type_suffix (0).element_bits);
}
};
-SHAPE (unary_convert)
+SHAPE (unary_convert);
/* sv<t0>_t svfoo_t0[_t1](sv<t0>_t, sv<t1>_t)
r.type_suffix (0).element_bits, true);
}
};
-SHAPE (unary_convert_narrowt)
+SHAPE (unary_convert_narrowt);
/* sv<t0>_t svfoo_t0[_t1_g](sv<t0>_t, sv<t1>x<g_t, fpm_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (unary_convertxn_narrowt)
+SHAPE (unary_convertxn_narrowt);
/* sv<t0>x<g0>_t svfoo_t0[_t1_g](sv<t1>x<g1>_t)
return r.resolve_conversion (r.mode_suffix_id, type);
}
};
-SHAPE (unary_convertxn)
+SHAPE (unary_convertxn);
/* sv<t0>_t svfoo_t0[_t1_g](sv<t1>x<g1>_t)
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (unary_convertxn_narrow)
+SHAPE (unary_convertxn_narrow);
/* sv<t0>_t svfoo_<t0>(sv<t0>_t, uint64_t)
return c.require_immediate_lane_index (1, 0);
}
};
-SHAPE (unary_lane)
+SHAPE (unary_lane);
/* sv<t0>_t svfoo[_t0](sv<t0:half>_t). */
struct unary_long_def : public overloaded_base<0>
return r.report_no_such_form (type);
}
};
-SHAPE (unary_long)
+SHAPE (unary_long);
/* sv<t0>_t svfoo[_n]_t0(<t0>_t). */
struct unary_n_def : public overloaded_base<1>
gcc_unreachable ();
}
};
-SHAPE (unary_n)
+SHAPE (unary_n);
/* sv<t0:half>_t svfoo[_t0](sv<t0>_t). */
typedef unary_narrowb_base<> unary_narrowb_def;
-SHAPE (unary_narrowb)
+SHAPE (unary_narrowb);
/* sv<t0:half>_t svfoo[_t0](sv<t0:half>_t, sv<t0>_t). */
typedef unary_narrowt_base<> unary_narrowt_def;
-SHAPE (unary_narrowt)
+SHAPE (unary_narrowt);
/* sv<t0:uint:half>_t svfoo[_t0](sv<t0>_t). */
typedef unary_narrowb_base<TYPE_unsigned> unary_narrowb_to_uint_def;
-SHAPE (unary_narrowb_to_uint)
+SHAPE (unary_narrowb_to_uint);
/* sv<t0:uint:half>_t svfoo[_t0](sv<t0:uint:half>_t, sv<t0>_t). */
typedef unary_narrowt_base<TYPE_unsigned> unary_narrowt_to_uint_def;
-SHAPE (unary_narrowt_to_uint)
+SHAPE (unary_narrowt_to_uint);
/* svbool_t svfoo(svbool_t). */
struct unary_pred_def : public nonoverloaded_base
build_all (b, "v0,v0", group, MODE_none);
}
};
-SHAPE (unary_pred)
+SHAPE (unary_pred);
/* sv<t0:int>_t svfoo[_t0](sv<t0>_t)
return r.resolve_unary (TYPE_signed);
}
};
-SHAPE (unary_to_int)
+SHAPE (unary_to_int);
/* sv<t0:uint>_t svfoo[_t0](sv<t0>_t)
return r.resolve_unary (TYPE_unsigned);
}
};
-SHAPE (unary_to_uint)
+SHAPE (unary_to_uint);
/* sv<t0>_t svfoo[_t0](sv<t0:uint>_t)
return r.report_no_such_form (type);
}
};
-SHAPE (unary_uint)
+SHAPE (unary_uint);
/* sv<t0>_t svfoo[_<t0>](sv<t0:half>_t)
return r.report_no_such_form (type);
}
};
-SHAPE (unary_widen)
+SHAPE (unary_widen);
/* void svfoo_t0[_t1](uint64_t, svbool_t, svbool_t, sv<t1>_t)
return c.require_immediate_range (0, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (unary_za_m)
+SHAPE (unary_za_m);
/* void svfoo_t0[_t1]_g(uint32_t, sv<t1>x<g>_t). */
struct unary_za_slice_def : public overloaded_base<1>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (unary_za_slice)
+SHAPE (unary_za_slice);
/* sv<t0>x<g>_t svfoo[_t0_g](sv<t0>x<g>_t). */
struct unaryxn_def : public unary_def
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (unaryxn)
+SHAPE (unaryxn);
/* void svfoo_t0[_t1_g](uint64_t, uint32_t, sv<t1>x<g>_t). */
struct write_za_def : public overloaded_base<1>
return c.require_immediate_range (0, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (write_za)
+SHAPE (write_za);
/* void svfoo_t0[_t1](uint64_t, uint32_t, svbool_t, sv<t1>_t)
return c.require_immediate_range (0, 0, c.num_za_tiles () - 1);
}
};
-SHAPE (write_za_m)
+SHAPE (write_za_m);
/* void svfoo_t0[_t1_g](uint32_t, sv<t1>x<g>_t). */
struct write_za_slice_def : public overloaded_base<1>
return r.resolve_to (r.mode_suffix_id, type);
}
};
-SHAPE (write_za_slice)
+SHAPE (write_za_slice);
/* MOVT (vector to table)
Variants are also available for:
return c.require_immediate_range (0, 0, 0);
}
};
-SHAPE (write_zt)
+SHAPE (write_zt);
/* MOVT (vector to table)
Variants are also available for:
&& c.require_immediate_range (2, 0, 3);
}
};
-SHAPE (write_lane_zt)
+SHAPE (write_lane_zt);
}
projects / thirdparty / gcc.git / commitdiff
