]>
Commit | Line | Data |
---|---|---|
5b212be6 CG |
1 | /* |
2 | * QEMU TILE-Gx helpers | |
3 | * | |
4 | * Copyright (c) 2015 Chen Gang | |
5 | * | |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2.1 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
17 | * License along with this library; if not, see | |
18 | * <http://www.gnu.org/licenses/lgpl-2.1.html> | |
19 | */ | |
20 | ||
b98ba684 | 21 | #include "qemu/osdep.h" |
5b212be6 | 22 | #include "cpu.h" |
63c91552 | 23 | #include "exec/exec-all.h" |
5b212be6 | 24 | #include "exec/helper-proto.h" |
ba1fc78f | 25 | #include <zlib.h> /* For crc32 */ |
fec7daab | 26 | #include "syscall_defs.h" |
5b212be6 CG |
27 | |
28 | void helper_exception(CPUTLGState *env, uint32_t excp) | |
29 | { | |
06887771 | 30 | CPUState *cs = env_cpu(env); |
5b212be6 CG |
31 | |
32 | cs->exception_index = excp; | |
33 | cpu_loop_exit(cs); | |
34 | } | |
35 | ||
fec7daab CG |
36 | void helper_ext01_ics(CPUTLGState *env) |
37 | { | |
38 | uint64_t val = env->spregs[TILEGX_SPR_EX_CONTEXT_0_1]; | |
39 | ||
40 | switch (val) { | |
41 | case 0: | |
42 | case 1: | |
43 | env->spregs[TILEGX_SPR_CRITICAL_SEC] = val; | |
44 | break; | |
45 | default: | |
46 | #if defined(CONFIG_USER_ONLY) | |
47 | env->signo = TARGET_SIGILL; | |
48 | env->sigcode = TARGET_ILL_ILLOPC; | |
49 | helper_exception(env, TILEGX_EXCP_SIGNAL); | |
50 | #else | |
51 | helper_exception(env, TILEGX_EXCP_OPCODE_UNIMPLEMENTED); | |
52 | #endif | |
53 | break; | |
54 | } | |
55 | } | |
56 | ||
7f41a8d6 RH |
57 | uint64_t helper_revbits(uint64_t arg) |
58 | { | |
59 | return revbit64(arg); | |
60 | } | |
61 | ||
5b212be6 CG |
62 | /* |
63 | * Functional Description | |
64 | * uint64_t a = rf[SrcA]; | |
65 | * uint64_t b = rf[SrcB]; | |
66 | * uint64_t d = rf[Dest]; | |
67 | * uint64_t output = 0; | |
68 | * unsigned int counter; | |
69 | * for (counter = 0; counter < (WORD_SIZE / BYTE_SIZE); counter++) | |
70 | * { | |
71 | * int sel = getByte (b, counter) & 0xf; | |
72 | * uint8_t byte = (sel < 8) ? getByte (d, sel) : getByte (a, (sel - 8)); | |
73 | * output = setByte (output, counter, byte); | |
74 | * } | |
75 | * rf[Dest] = output; | |
76 | */ | |
77 | uint64_t helper_shufflebytes(uint64_t dest, uint64_t srca, uint64_t srcb) | |
78 | { | |
79 | uint64_t vdst = 0; | |
80 | int count; | |
81 | ||
82 | for (count = 0; count < 64; count += 8) { | |
83 | uint64_t sel = srcb >> count; | |
84 | uint64_t src = (sel & 8) ? srca : dest; | |
85 | vdst |= extract64(src, (sel & 7) * 8, 8) << count; | |
86 | } | |
87 | ||
88 | return vdst; | |
89 | } | |
ba1fc78f RH |
90 | |
91 | uint64_t helper_crc32_8(uint64_t accum, uint64_t input) | |
92 | { | |
93 | uint8_t buf = input; | |
94 | ||
95 | /* zlib crc32 converts the accumulator and output to one's complement. */ | |
96 | return crc32(accum ^ 0xffffffff, &buf, 1) ^ 0xffffffff; | |
97 | } | |
98 | ||
99 | uint64_t helper_crc32_32(uint64_t accum, uint64_t input) | |
100 | { | |
101 | uint8_t buf[4]; | |
102 | ||
103 | stl_le_p(buf, input); | |
104 | ||
105 | /* zlib crc32 converts the accumulator and output to one's complement. */ | |
106 | return crc32(accum ^ 0xffffffff, buf, 4) ^ 0xffffffff; | |
107 | } | |
9ff5b57c RH |
108 | |
109 | uint64_t helper_cmula(uint64_t srcd, uint64_t srca, uint64_t srcb) | |
110 | { | |
111 | uint32_t reala = (int16_t)srca; | |
112 | uint32_t imaga = (int16_t)(srca >> 16); | |
113 | uint32_t realb = (int16_t)srcb; | |
114 | uint32_t imagb = (int16_t)(srcb >> 16); | |
115 | uint32_t reald = srcd; | |
116 | uint32_t imagd = srcd >> 32; | |
117 | uint32_t realr = reala * realb - imaga * imagb + reald; | |
118 | uint32_t imagr = reala * imagb + imaga * realb + imagd; | |
119 | ||
120 | return deposit64(realr, 32, 32, imagr); | |
121 | } | |
122 | ||
123 | uint64_t helper_cmulaf(uint64_t srcd, uint64_t srca, uint64_t srcb) | |
124 | { | |
125 | uint32_t reala = (int16_t)srca; | |
126 | uint32_t imaga = (int16_t)(srca >> 16); | |
127 | uint32_t realb = (int16_t)srcb; | |
128 | uint32_t imagb = (int16_t)(srcb >> 16); | |
129 | uint32_t reald = (int16_t)srcd; | |
130 | uint32_t imagd = (int16_t)(srcd >> 16); | |
131 | int32_t realr = reala * realb - imaga * imagb; | |
132 | int32_t imagr = reala * imagb + imaga * realb; | |
133 | ||
134 | return deposit32((realr >> 15) + reald, 16, 16, (imagr >> 15) + imagd); | |
135 | } | |
136 | ||
137 | uint64_t helper_cmul2(uint64_t srca, uint64_t srcb, int shift, int round) | |
138 | { | |
139 | uint32_t reala = (int16_t)srca; | |
140 | uint32_t imaga = (int16_t)(srca >> 16); | |
141 | uint32_t realb = (int16_t)srcb; | |
142 | uint32_t imagb = (int16_t)(srcb >> 16); | |
143 | int32_t realr = reala * realb - imaga * imagb + round; | |
144 | int32_t imagr = reala * imagb + imaga * realb + round; | |
145 | ||
146 | return deposit32(realr >> shift, 16, 16, imagr >> shift); | |
147 | } |