s390x/tcg/translate_vx.c.inc

32  *  always 16 (128 bit). What gvec code calls "vece", s390x calls "es",
45 #define NUM_VEC_ELEMENT_BYTES(es) (1 << (es))
46 #define NUM_VEC_ELEMENTS(es) (16 / NUM_VEC_ELEMENT_BYTES(es))
47 #define NUM_VEC_ELEMENT_BITS(es) (NUM_VEC_ELEMENT_BYTES(es) * BITS_PER_BYTE)
60 static inline bool valid_vec_element(uint16_t enr, MemOp es)
62     return !(enr & ~(NUM_VEC_ELEMENTS(es) - 1));
169                                     uint8_t es)
174     tcg_gen_andi_i64(tmp, enr, NUM_VEC_ELEMENTS(es) - 1);
177     tcg_gen_shli_i64(tmp, tmp, es);
179     tcg_gen_xori_i64(tmp, tmp, 8 - NUM_VEC_ELEMENT_BYTES(es));
227 #define gen_gvec_dup_i64(es, v1, c) \
228     tcg_gen_gvec_dup_i64(es, vec_full_reg_offset(v1), 16, 16, c)
232 #define gen_gvec_dup_imm(es, v1, c) \
233     tcg_gen_gvec_dup_imm(es, vec_full_reg_offset(v1), 16, 16, c);
234 #define gen_gvec_fn_2(fn, es, v1, v2) \
235     tcg_gen_gvec_##fn(es, vec_full_reg_offset(v1), vec_full_reg_offset(v2), \
237 #define gen_gvec_fn_2i(fn, es, v1, v2, c) \
238     tcg_gen_gvec_##fn(es, vec_full_reg_offset(v1), vec_full_reg_offset(v2), \
240 #define gen_gvec_fn_2s(fn, es, v1, v2, s) \
241     tcg_gen_gvec_##fn(es, vec_full_reg_offset(v1), vec_full_reg_offset(v2), \
243 #define gen_gvec_fn_3(fn, es, v1, v2, v3) \
244     tcg_gen_gvec_##fn(es, vec_full_reg_offset(v1), vec_full_reg_offset(v2), \
246 #define gen_gvec_fn_4(fn, es, v1, v2, v3, v4) \
247     tcg_gen_gvec_##fn(es, vec_full_reg_offset(v1), vec_full_reg_offset(v2), \
320     const uint8_t es = s->insn->data;
324     if (!valid_vec_element(enr, es)) {
330     read_vec_element_i64(tmp, get_field(s, v2), enr, es);
334     tcg_gen_qemu_ld_i64(tmp, o->addr1, get_mem_index(s), MO_TE | es);
335     write_vec_element_i64(tmp, get_field(s, v1), enr, es);
376     const uint8_t es = get_field(s, m4);
377     const uint8_t bits = NUM_VEC_ELEMENT_BITS(es);
383     if (es > ES_64) {
396     gen_gvec_dup_imm(es, get_field(s, v1), mask);
421     const uint8_t es = get_field(s, m3);
424     if (es > ES_64) {
430     tcg_gen_qemu_ld_i64(tmp, o->addr1, get_mem_index(s), MO_TE | es);
431     gen_gvec_dup_i64(es, get_field(s, v1), tmp);
437     const uint8_t es = s->insn->data;
441     if (!valid_vec_element(enr, es)) {
447     tcg_gen_qemu_ld_i64(tmp, o->addr1, get_mem_index(s), MO_LE | es);
448     write_vec_element_i64(tmp, get_field(s, v1), enr, es);
454     const uint8_t es = get_field(s, m3);
457     if (es < ES_16 || es > ES_64) {
463     tcg_gen_qemu_ld_i64(tmp, o->addr1, get_mem_index(s), MO_LE | es);
464     gen_gvec_dup_i64(es, get_field(s, v1), tmp);
472     int es, lshift;
478         es = m3;
482         es = ES_32;
491     tcg_gen_qemu_ld_i64(tmp, o->addr1, get_mem_index(s), MO_LE | es);
501     const uint8_t es = get_field(s, m3);
504     if (es < ES_16 || es > ES_128) {
513     if (es == ES_128) {
531     switch (es) {
554     const uint8_t es = s->insn->data;
558     if (!valid_vec_element(enr, es)) {
564     tcg_gen_qemu_ld_i64(tmp, o->addr1, get_mem_index(s), MO_TE | es);
565     write_vec_element_i64(tmp, get_field(s, v1), enr, es);
571     const uint8_t es = s->insn->data;
575     if (!valid_vec_element(enr, es)) {
581     write_vec_element_i64(tmp, get_field(s, v1), enr, es);
587     const uint8_t es = get_field(s, m3);
589     if (es < ES_16 || es > ES_64) {
603     switch (es) {
625     const uint8_t es = get_field(s, m4);
628     if (es > ES_64) {
635         uint8_t enr = get_field(s, d2) & (NUM_VEC_ELEMENTS(es) - 1);
637         read_vec_element_i64(o->out, get_field(s, v3), enr, es);
642     get_vec_element_ptr_i64(ptr, get_field(s, v3), o->addr1, es);
643     switch (es) {
664     uint8_t es = get_field(s, m3);
668     switch (es) {
685             es = ES_32;
696     tcg_gen_qemu_ld_i64(t, o->addr1, get_mem_index(s), MO_TE | es);
697     gen_gvec_dup_imm(es, get_field(s, v1), 0);
698     write_vec_element_i64(t, get_field(s, v1), enr, es);
764     const uint8_t es = get_field(s, m4);
767     if (es > ES_64) {
774         uint8_t enr = get_field(s, d2) & (NUM_VEC_ELEMENTS(es) - 1);
776         write_vec_element_i64(o->in2, get_field(s, v1), enr, es);
781     get_vec_element_ptr_i64(ptr, get_field(s, v1), o->addr1, es);
782     switch (es) {
825     const uint8_t es = get_field(s, m4);
829     if (es > ES_64) {
837         for (dst_idx = NUM_VEC_ELEMENTS(es) - 1; dst_idx >= 0; dst_idx--) {
840                 read_vec_element_i64(tmp, v2, src_idx, es);
842                 read_vec_element_i64(tmp, v3, src_idx, es);
844             write_vec_element_i64(tmp, v1, dst_idx, es);
848         for (dst_idx = 0; dst_idx < NUM_VEC_ELEMENTS(es); dst_idx++) {
849             src_idx = (dst_idx + NUM_VEC_ELEMENTS(es)) / 2;
851                 read_vec_element_i64(tmp, v2, src_idx, es);
853                 read_vec_element_i64(tmp, v3, src_idx, es);
855             write_vec_element_i64(tmp, v1, dst_idx, es);
866     const uint8_t es = get_field(s, m4);
893     if (es == ES_8 || es > ES_64) {
901             gen_gvec_3_ptr(v1, v2, v3, tcg_env, 0, vpks_cc[es - 1]);
904             gen_gvec_3_ool(v1, v2, v3, 0, vpks[es - 1]);
909             gen_gvec_3_ptr(v1, v2, v3, tcg_env, 0, vpkls_cc[es - 1]);
912             gen_gvec_3_ool(v1, v2, v3, 0, vpkls[es - 1]);
934             gen_gvec_3_ool(v1, v2, v3, 0, vpk[es - 1]);
968     const uint8_t es = get_field(s, m4);
970     if (es > ES_64 || !valid_vec_element(enr, es)) {
975     tcg_gen_gvec_dup_mem(es, vec_full_reg_offset(get_field(s, v1)),
976                          vec_reg_offset(get_field(s, v3), enr, es),
984     const uint8_t es = get_field(s, m3);
986     if (es > ES_64) {
991     gen_gvec_dup_imm(es, get_field(s, v1), data);
997     const uint8_t es = s->insn->data;
1001     if (!valid_vec_element(enr, es)) {
1007     read_vec_element_i64(tmp, get_field(s, v2), enr, es);
1011     read_vec_element_i64(tmp, get_field(s, v1), enr, es);
1012     tcg_gen_qemu_st_i64(tmp, o->addr1, get_mem_index(s), MO_TE | es);
1026     const uint8_t es = get_field(s, m3);
1030     switch (es) {
1049     read_vec_element_i64(tmp, get_field(s, v2), idx1, es | MO_SIGN);
1051     read_vec_element_i64(tmp, get_field(s, v2), idx2, es | MO_SIGN);
1075     const uint8_t es = s->insn->data;
1079     if (!valid_vec_element(enr, es)) {
1085     read_vec_element_i64(tmp, get_field(s, v1), enr, es);
1086     tcg_gen_qemu_st_i64(tmp, o->addr1, get_mem_index(s), MO_LE | es);
1092     const uint8_t es = get_field(s, m3);
1095     if (es < ES_16 || es > ES_128) {
1107     if (es == ES_128) {
1122     switch (es) {
1146     const uint8_t es = s->insn->data;
1150     if (!valid_vec_element(enr, es)) {
1156     read_vec_element_i64(tmp, get_field(s, v1), enr, es);
1157     tcg_gen_qemu_st_i64(tmp, o->addr1, get_mem_index(s), MO_TE | es);
1163     const uint8_t es = get_field(s, m3);
1166     if (es < ES_16 || es > ES_64) {
1181     switch (es) {
1283     const uint8_t es = get_field(s, m4);
1285     if (es > ES_128) {
1288     } else if (es == ES_128) {
1293     gen_gvec_fn_3(add, es, get_field(s, v1), get_field(s, v2),
1298 static void gen_acc(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b, uint8_t es)
1300     const uint8_t msb_bit_nr = NUM_VEC_ELEMENT_BITS(es) - 1;
1301     TCGv_i64 msb_mask = tcg_constant_i64(dup_const(es, 1ull << msb_bit_nr));
1362     const uint8_t es = get_field(s, m4);
1370     if (es > ES_128) {
1373     } else if (es == ES_128) {
1379                get_field(s, v3), &g[es]);
1479     const uint8_t es = get_field(s, m4);
1487     if (es > ES_64) {
1492                get_field(s, v3), &g[es]);
1521     const uint8_t es = get_field(s, m4);
1529     if (es > ES_64) {
1534                get_field(s, v3), &g[es]);
1556     uint8_t es = get_field(s, m3);
1557     const uint8_t enr = NUM_VEC_ELEMENTS(es) / 2 - 1;
1559     if (es > ES_64) {
1564         es |= MO_SIGN;
1569     read_vec_element_i64(o->in1, get_field(s, v1), enr, es);
1570     read_vec_element_i64(o->in2, get_field(s, v2), enr, es);
1576     const uint8_t es = get_field(s, m4);
1579     if (es > ES_64) {
1584     tcg_gen_gvec_cmp(cond, es,
1611     const uint8_t es = get_field(s, m3);
1619     if (es > ES_64) {
1623     gen_gvec_2(get_field(s, v1), get_field(s, v2), &g[es]);
1639     const uint8_t es = get_field(s, m3);
1647     if (es > ES_64) {
1651     gen_gvec_2(get_field(s, v1), get_field(s, v2), &g[es]);
1664     const uint8_t es = get_field(s, m4);
1672     if (es > ES_64) {
1677                get_field(s, v3), &g[es]);
1683     const uint8_t es = get_field(s, m5);
1691     if (es > ES_64) {
1696                get_field(s, v3), get_field(s, v4), &g[es]);
1702     const uint8_t es = get_field(s, m3);
1704     if (es > ES_64) {
1709     gen_gvec_fn_2(neg, es, get_field(s, v1), get_field(s, v2));
1715     const uint8_t es = get_field(s, m3);
1717     if (es > ES_64) {
1722     gen_gvec_fn_2(abs, es, get_field(s, v1), get_field(s, v2));
1731     const uint8_t es = get_field(s, m4);
1733     if (es > ES_64) {
1740         gen_gvec_fn_3(smax, es, v1, v2, v3);
1743         gen_gvec_fn_3(umax, es, v1, v2, v3);
1746         gen_gvec_fn_3(smin, es, v1, v2, v3);
1749         gen_gvec_fn_3(umin, es, v1, v2, v3);
1795     const uint8_t es = get_field(s, m5);
1833     if (es > ES_32) {
1840         fn = &g_vmal[es];
1843         fn = &g_vmah[es];
1846         fn = &g_vmalh[es];
1849         fn = &g_vmae[es];
1852         fn = &g_vmale[es];
1855         fn = &g_vmao[es];
1858         fn = &g_vmalo[es];
1885     const uint8_t es = get_field(s, m4);
1918     if (es > ES_32) {
1925         gen_gvec_fn_3(mul, es, get_field(s, v1),
1929         fn = &g_vmh[es];
1932         fn = &g_vmlh[es];
1935         fn = &g_vme[es];
1938         fn = &g_vmle[es];
1941         fn = &g_vmo[es];
1944         fn = &g_vmlo[es];
2037     const uint8_t es = get_field(s, m3);
2045     if (es > ES_64 || (es != ES_8 && !s390_has_feat(S390_FEAT_VECTOR_ENH))) {
2050     gen_gvec_2(get_field(s, v1), get_field(s, v2), &g[es]);
2076     const uint8_t es = get_field(s, m5);
2078                        (NUM_VEC_ELEMENT_BITS(es) - 1);
2088     if (es > ES_64) {
2094                 get_field(s, v3), i4, &g[es]);
2100     const uint8_t es = get_field(s, m4);
2105     if (es > ES_64) {
2112         gen_gvec_fn_3(shlv, es, v1, v2, v3);
2115         gen_gvec_fn_3(rotlv, es, v1, v2, v3);
2118         gen_gvec_fn_3(sarv, es, v1, v2, v3);
2121         gen_gvec_fn_3(shrv, es, v1, v2, v3);
2131     const uint8_t es = get_field(s, m4);
2133                        (NUM_VEC_ELEMENT_BITS(es) - 1);
2138     if (es > ES_64) {
2146             gen_gvec_fn_2i(shli, es, v1, v3, d2);
2149             gen_gvec_fn_2i(rotli, es, v1, v3, d2);
2152             gen_gvec_fn_2i(sari, es, v1, v3, d2);
2155             gen_gvec_fn_2i(shri, es, v1, v3, d2);
2163         tcg_gen_andi_i32(shift, shift, NUM_VEC_ELEMENT_BITS(es) - 1);
2166             gen_gvec_fn_2s(shls, es, v1, v3, shift);
2169             gen_gvec_fn_2s(rotls, es, v1, v3, shift);
2172             gen_gvec_fn_2s(sars, es, v1, v3, shift);
2175             gen_gvec_fn_2s(shrs, es, v1, v3, shift);
2285     const uint8_t es = get_field(s, m4);
2287     if (es > ES_128) {
2290     } else if (es == ES_128) {
2295     gen_gvec_fn_3(sub, es, get_field(s, v1), get_field(s, v2),
2328     const uint8_t es = get_field(s, m4);
2336     if (es > ES_128) {
2339     } else if (es == ES_128) {
2345                get_field(s, v3), &g[es]);
2399     const uint8_t es = get_field(s, m4);
2403     if (es == ES_8 || es > ES_32) {
2411         uint8_t idx = dst_idx * NUM_VEC_ELEMENTS(es) / 2;
2412         const uint8_t max_idx = idx + NUM_VEC_ELEMENTS(es) / 2 - 1;
2414         read_vec_element_i64(sum, get_field(s, v3), max_idx, es);
2416             read_vec_element_i64(tmp, get_field(s, v2), idx, es);
2426     const uint8_t es = get_field(s, m4);
2427     const uint8_t max_idx = NUM_VEC_ELEMENTS(es) - 1;
2431     if (es < ES_32 || es > ES_64) {
2442     read_vec_element_i64(suml, get_field(s, v3), max_idx, es);
2444         read_vec_element_i64(tmpl, get_field(s, v2), idx, es);
2454     const uint8_t es = get_field(s, m4);
2458     if (es > ES_16) {
2466         uint8_t idx = dst_idx * NUM_VEC_ELEMENTS(es) / 4;
2467         const uint8_t max_idx = idx + NUM_VEC_ELEMENTS(es) / 4 - 1;
2469         read_vec_element_i32(sum, get_field(s, v3), max_idx, es);
2471             read_vec_element_i32(tmp, get_field(s, v2), idx, es);
2489     const uint8_t es = get_field(s, m4);
2501     if (es > ES_32) {
2508                        get_field(s, v3), tcg_env, m5, g_cc[es]);
2512                        get_field(s, v3), m5, g[es]);
2519     const uint8_t es = get_field(s, m4);
2532     if (es > ES_32 || m5 & ~0x3) {
2539                        get_field(s, v3), tcg_env, m5, g_cc[es]);
2543                        get_field(s, v3), m5, g[es]);
2550     const uint8_t es = get_field(s, m4);
2563     if (es > ES_32 || m5 & ~0x3) {
2570                        get_field(s, v3), tcg_env, m5, g_cc[es]);
2574                        get_field(s, v3), m5, g[es]);
2581     const uint8_t es = get_field(s, m3);
2594     if (es > ES_32 || m5 & ~0x1) {
2601                        tcg_env, 0, g_cc[es]);
2605                        g[es]);
2612     const uint8_t es = get_field(s, m5);
2635     if (es > ES_32) {
2644                            tcg_env, m6, g_cc_rt[es]);
2648                            tcg_env, m6, g_cc[es]);
2655                            m6, g_rt[es]);
2659                            m6, g[es]);
2674     const uint8_t es = get_field(s, m5);
2678     if (es > ES_32 || m6 & ~2) {
2685                    tcg_env, 0, fns[es][zs]);