1 | /* |
2 | * QEMU TCG support -- s390x vector utilitites |
3 | * |
4 | * Copyright (C) 2019 Red Hat Inc |
5 | * |
6 | * Authors: |
7 | * David Hildenbrand <david@redhat.com> |
8 | * |
9 | * This work is licensed under the terms of the GNU GPL, version 2 or later. |
10 | * See the COPYING file in the top-level directory. |
11 | */ |
12 | #ifndef S390X_VEC_H |
13 | #define S390X_VEC_H |
14 | |
15 | #include "tcg/tcg.h" |
16 | |
17 | typedef union S390Vector { |
18 | uint64_t doubleword[2]; |
19 | uint32_t word[4]; |
20 | uint16_t halfword[8]; |
21 | uint8_t byte[16]; |
22 | } S390Vector; |
23 | |
24 | /* |
25 | * Each vector is stored as two 64bit host values. So when talking about |
26 | * byte/halfword/word numbers, we have to take care of proper translation |
27 | * between element numbers. |
28 | * |
29 | * Big Endian (target/possible host) |
30 | * B: [ 0][ 1][ 2][ 3][ 4][ 5][ 6][ 7] - [ 8][ 9][10][11][12][13][14][15] |
31 | * HW: [ 0][ 1][ 2][ 3] - [ 4][ 5][ 6][ 7] |
32 | * W: [ 0][ 1] - [ 2][ 3] |
33 | * DW: [ 0] - [ 1] |
34 | * |
35 | * Little Endian (possible host) |
36 | * B: [ 7][ 6][ 5][ 4][ 3][ 2][ 1][ 0] - [15][14][13][12][11][10][ 9][ 8] |
37 | * HW: [ 3][ 2][ 1][ 0] - [ 7][ 6][ 5][ 4] |
38 | * W: [ 1][ 0] - [ 3][ 2] |
39 | * DW: [ 0] - [ 1] |
40 | */ |
41 | #ifndef HOST_WORDS_BIGENDIAN |
42 | #define H1(x) ((x) ^ 7) |
43 | #define H2(x) ((x) ^ 3) |
44 | #define H4(x) ((x) ^ 1) |
45 | #else |
46 | #define H1(x) (x) |
47 | #define H2(x) (x) |
48 | #define H4(x) (x) |
49 | #endif |
50 | |
51 | static inline uint8_t s390_vec_read_element8(const S390Vector *v, uint8_t enr) |
52 | { |
53 | g_assert(enr < 16); |
54 | return v->byte[H1(enr)]; |
55 | } |
56 | |
57 | static inline uint16_t s390_vec_read_element16(const S390Vector *v, uint8_t enr) |
58 | { |
59 | g_assert(enr < 8); |
60 | return v->halfword[H2(enr)]; |
61 | } |
62 | |
63 | static inline uint32_t s390_vec_read_element32(const S390Vector *v, uint8_t enr) |
64 | { |
65 | g_assert(enr < 4); |
66 | return v->word[H4(enr)]; |
67 | } |
68 | |
69 | static inline uint64_t s390_vec_read_element64(const S390Vector *v, uint8_t enr) |
70 | { |
71 | g_assert(enr < 2); |
72 | return v->doubleword[enr]; |
73 | } |
74 | |
75 | static inline uint64_t s390_vec_read_element(const S390Vector *v, uint8_t enr, |
76 | uint8_t es) |
77 | { |
78 | switch (es) { |
79 | case MO_8: |
80 | return s390_vec_read_element8(v, enr); |
81 | case MO_16: |
82 | return s390_vec_read_element16(v, enr); |
83 | case MO_32: |
84 | return s390_vec_read_element32(v, enr); |
85 | case MO_64: |
86 | return s390_vec_read_element64(v, enr); |
87 | default: |
88 | g_assert_not_reached(); |
89 | } |
90 | } |
91 | |
92 | static inline void s390_vec_write_element8(S390Vector *v, uint8_t enr, |
93 | uint8_t data) |
94 | { |
95 | g_assert(enr < 16); |
96 | v->byte[H1(enr)] = data; |
97 | } |
98 | |
99 | static inline void s390_vec_write_element16(S390Vector *v, uint8_t enr, |
100 | uint16_t data) |
101 | { |
102 | g_assert(enr < 8); |
103 | v->halfword[H2(enr)] = data; |
104 | } |
105 | |
106 | static inline void s390_vec_write_element32(S390Vector *v, uint8_t enr, |
107 | uint32_t data) |
108 | { |
109 | g_assert(enr < 4); |
110 | v->word[H4(enr)] = data; |
111 | } |
112 | |
113 | static inline void s390_vec_write_element64(S390Vector *v, uint8_t enr, |
114 | uint64_t data) |
115 | { |
116 | g_assert(enr < 2); |
117 | v->doubleword[enr] = data; |
118 | } |
119 | |
120 | static inline void s390_vec_write_element(S390Vector *v, uint8_t enr, |
121 | uint8_t es, uint64_t data) |
122 | { |
123 | switch (es) { |
124 | case MO_8: |
125 | s390_vec_write_element8(v, enr, data); |
126 | break; |
127 | case MO_16: |
128 | s390_vec_write_element16(v, enr, data); |
129 | break; |
130 | case MO_32: |
131 | s390_vec_write_element32(v, enr, data); |
132 | break; |
133 | case MO_64: |
134 | s390_vec_write_element64(v, enr, data); |
135 | break; |
136 | default: |
137 | g_assert_not_reached(); |
138 | } |
139 | } |
140 | |
141 | #endif /* S390X_VEC_H */ |
142 | |