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