arm/tcg/translate-a64.c

652  * - if FPCR.NEP == 0, clear the high elements of reg
653  * - if FPCR.NEP == 1, set the high elements of reg from mergereg
654  *   (i.e. merge the result with those high elements)
666      * Move from mergereg to reg; this sets the high elements and
676  * Write a single-prec result, but only clear the higher elements
694  * Write a half-prec result, but only clear the higher elements
1420 /* Likewise, but vector MO_64 must have two elements. */
3891     int elements; /* elements per vector */
3921      * promote consecutive little-endian elements below.
3927      * Consecutive little-endian elements from a single register
3940     elements = (a->q ? 16 : 8) >> size;
3944         for (e = 0; e < elements; e++) {
3982     int elements; /* elements per vector */
4012      * promote consecutive little-endian elements below.
4018      * Consecutive little-endian elements from a single register
4031     elements = (a->q ? 16 : 8) >> size;
4035         for (e = 0; e < elements; e++) {
4161         /* Load and replicate to all elements */
4621      * are vectors of identical elements of size e = 2, 4, 8, 16, 32 or
4628      * 64 bit elements: immn = 1, imms = <length of run - 1>
4629      * 32 bit elements: immn = 0, imms = 0 : <length of run - 1>
4630      * 16 bit elements: immn = 0, imms = 10 : <length of run - 1>
4631      *  8 bit elements: immn = 0, imms = 110 : <length of run - 1>
4632      *  4 bit elements: immn = 0, imms = 1110 : <length of run - 1>
4633      *  2 bit elements: immn = 0, imms = 11110 : <length of run - 1>
4897 typedef int simd_permute_idx_fn(int i, int part, int elements);
4904     int elements = datasize >> esz;
4918     for (int i = 0; i < elements; i++) {
4921         idx = fn(i, part, elements);
4922         read_vec_element(s, tcg_ele, (idx & elements ? a->rm : a->rn),
4923                          idx & (elements - 1), esz);
4941 static int permute_load_uzp(int i, int part, int elements)
4949 static int permute_load_trn(int i, int part, int elements)
4951     return (i & 1) * elements + (i & ~1) + part;
4957 static int permute_load_zip(int i, int part, int elements)
4959     return (i & 1) * elements + ((part * elements + i) >> 1);
6183  * Implement these inline, as the number of elements are limited
6185  * even/odd elements instead of top/bottom half.
7178     int elements = (a->q ? 16 : 8) >> a->esz;
7180     /* Reject MO_64, and MO_32 without Q: a minimum of 4 elements. */
7181     if (elements < 4) {
7192     for (int i = 1; i < elements; i++) {
7482     for (int i = 0, elements = 8 >> esz; i < elements; i++) {
7628     for (int i = 0, elements = 8 >> esz; i < elements; i++) {