decoder.isa (11723:0596db108c53) decoder.isa (11724:d92c26d481b7)
1// -*- mode:c++ -*-
2
3// Copyright (c) 2015 RISC-V Foundation
4// Copyright (c) 2016 The University of Virginia
5// All rights reserved.
6//
7// Redistribution and use in source and binary forms, with or without
8// modification, are permitted provided that the following conditions are

--- 136 unchanged lines hidden (view full) ---

145 }
146
147 0x33: decode FUNCT3 {
148 format ROp {
149 0x0: decode FUNCT7 {
150 0x0: add({{
151 Rd = Rs1_sd + Rs2_sd;
152 }});
1// -*- mode:c++ -*-
2
3// Copyright (c) 2015 RISC-V Foundation
4// Copyright (c) 2016 The University of Virginia
5// All rights reserved.
6//
7// Redistribution and use in source and binary forms, with or without
8// modification, are permitted provided that the following conditions are

--- 136 unchanged lines hidden (view full) ---

145 }
146
147 0x33: decode FUNCT3 {
148 format ROp {
149 0x0: decode FUNCT7 {
150 0x0: add({{
151 Rd = Rs1_sd + Rs2_sd;
152 }});
153 0x1: mul({{
154 Rd = Rs1_sd*Rs2_sd;
155 }}, IntMultOp);
153 0x20: sub({{
154 Rd = Rs1_sd - Rs2_sd;
155 }});
156 }
157 0x1: decode FUNCT7 {
158 0x0: sll({{
159 Rd = Rs1 << Rs2<5:0>;
160 }});
156 0x20: sub({{
157 Rd = Rs1_sd - Rs2_sd;
158 }});
159 }
160 0x1: decode FUNCT7 {
161 0x0: sll({{
162 Rd = Rs1 << Rs2<5:0>;
163 }});
164 0x1: mulh({{
165 bool negate = (Rs1_sd < 0) != (Rs2_sd < 0);
166
167 uint64_t Rs1_lo = (uint32_t)std::abs(Rs1_sd);
168 uint64_t Rs1_hi = (uint64_t)std::abs(Rs1_sd) >> 32;
169 uint64_t Rs2_lo = (uint32_t)std::abs(Rs2_sd);
170 uint64_t Rs2_hi = (uint64_t)std::abs(Rs2_sd) >> 32;
171
172 uint64_t hi = Rs1_hi*Rs2_hi;
173 uint64_t mid1 = Rs1_hi*Rs2_lo;
174 uint64_t mid2 = Rs1_lo*Rs2_hi;
175 uint64_t lo = Rs2_lo*Rs1_lo;
176 uint64_t carry = ((uint64_t)(uint32_t)mid1
177 + (uint64_t)(uint32_t)mid2 + (lo >> 32)) >> 32;
178
179 uint64_t res = hi + (mid1 >> 32) + (mid2 >> 32) + carry;
180 Rd = negate ? ~res + (Rs1_sd*Rs2_sd == 0 ? 1 : 0) : res;
181 }}, IntMultOp);
161 }
162 0x2: decode FUNCT7 {
163 0x0: slt({{
164 Rd = (Rs1_sd < Rs2_sd) ? 1 : 0;
165 }});
182 }
183 0x2: decode FUNCT7 {
184 0x0: slt({{
185 Rd = (Rs1_sd < Rs2_sd) ? 1 : 0;
186 }});
187 0x1: mulhsu({{
188 bool negate = Rs1_sd < 0;
189 uint64_t Rs1_lo = (uint32_t)std::abs(Rs1_sd);
190 uint64_t Rs1_hi = (uint64_t)std::abs(Rs1_sd) >> 32;
191 uint64_t Rs2_lo = (uint32_t)Rs2;
192 uint64_t Rs2_hi = Rs2 >> 32;
193
194 uint64_t hi = Rs1_hi*Rs2_hi;
195 uint64_t mid1 = Rs1_hi*Rs2_lo;
196 uint64_t mid2 = Rs1_lo*Rs2_hi;
197 uint64_t lo = Rs1_lo*Rs2_lo;
198 uint64_t carry = ((uint64_t)(uint32_t)mid1
199 + (uint64_t)(uint32_t)mid2 + (lo >> 32)) >> 32;
200
201 uint64_t res = hi + (mid1 >> 32) + (mid2 >> 32) + carry;
202 Rd = negate ? ~res + (Rs1_sd*Rs2 == 0 ? 1 : 0) : res;
203 }}, IntMultOp);
166 }
167 0x3: decode FUNCT7 {
168 0x0: sltu({{
169 Rd = (Rs1 < Rs2) ? 1 : 0;
170 }});
204 }
205 0x3: decode FUNCT7 {
206 0x0: sltu({{
207 Rd = (Rs1 < Rs2) ? 1 : 0;
208 }});
209 0x1: mulhu({{
210 uint64_t Rs1_lo = (uint32_t)Rs1;
211 uint64_t Rs1_hi = Rs1 >> 32;
212 uint64_t Rs2_lo = (uint32_t)Rs2;
213 uint64_t Rs2_hi = Rs2 >> 32;
214
215 uint64_t hi = Rs1_hi*Rs2_hi;
216 uint64_t mid1 = Rs1_hi*Rs2_lo;
217 uint64_t mid2 = Rs1_lo*Rs2_hi;
218 uint64_t lo = Rs1_lo*Rs2_lo;
219 uint64_t carry = ((uint64_t)(uint32_t)mid1
220 + (uint64_t)(uint32_t)mid2 + (lo >> 32)) >> 32;
221
222 Rd = hi + (mid1 >> 32) + (mid2 >> 32) + carry;
223 }}, IntMultOp);
171 }
172 0x4: decode FUNCT7 {
173 0x0: xor({{
174 Rd = Rs1 ^ Rs2;
175 }});
224 }
225 0x4: decode FUNCT7 {
226 0x0: xor({{
227 Rd = Rs1 ^ Rs2;
228 }});
229 0x1: div({{
230 if (Rs2_sd == 0) {
231 Rd_sd = -1;
232 } else if (Rs1_sd == std::numeric_limits<int64_t>::min()
233 && Rs2_sd == -1) {
234 Rd_sd = std::numeric_limits<int64_t>::min();
235 } else {
236 Rd_sd = Rs1_sd/Rs2_sd;
237 }
238 }}, IntDivOp);
176 }
177 0x5: decode FUNCT7 {
178 0x0: srl({{
179 Rd = Rs1 >> Rs2<5:0>;
180 }});
239 }
240 0x5: decode FUNCT7 {
241 0x0: srl({{
242 Rd = Rs1 >> Rs2<5:0>;
243 }});
244 0x1: divu({{
245 if (Rs2 == 0) {
246 Rd = std::numeric_limits<uint64_t>::max();
247 } else {
248 Rd = Rs1/Rs2;
249 }
250 }}, IntDivOp);
181 0x20: sra({{
182 Rd_sd = Rs1_sd >> Rs2<5:0>;
183 }});
184 }
185 0x6: decode FUNCT7 {
186 0x0: or({{
187 Rd = Rs1 | Rs2;
188 }});
251 0x20: sra({{
252 Rd_sd = Rs1_sd >> Rs2<5:0>;
253 }});
254 }
255 0x6: decode FUNCT7 {
256 0x0: or({{
257 Rd = Rs1 | Rs2;
258 }});
259 0x1: rem({{
260 if (Rs2_sd == 0) {
261 Rd = Rs1_sd;
262 } else if (Rs1_sd == std::numeric_limits<int64_t>::min()
263 && Rs2_sd == -1) {
264 Rd = 0;
265 } else {
266 Rd = Rs1_sd%Rs2_sd;
267 }
268 }}, IntDivOp);
189 }
190 0x7: decode FUNCT7 {
191 0x0: and({{
192 Rd = Rs1 & Rs2;
193 }});
269 }
270 0x7: decode FUNCT7 {
271 0x0: and({{
272 Rd = Rs1 & Rs2;
273 }});
274 0x1: remu({{
275 if (Rs2 == 0) {
276 Rd = Rs1;
277 } else {
278 Rd = Rs1%Rs2;
279 }
280 }}, IntDivOp);
194 }
195 }
196 }
197
198 0x37: UOp::lui({{
199 Rd = (uint64_t)imm;
200 }});
201
202 0x3b: decode FUNCT3 {
203 format ROp {
204 0x0: decode FUNCT7 {
205 0x0: addw({{
206 Rd_sd = Rs1_sw + Rs2_sw;
207 }});
281 }
282 }
283 }
284
285 0x37: UOp::lui({{
286 Rd = (uint64_t)imm;
287 }});
288
289 0x3b: decode FUNCT3 {
290 format ROp {
291 0x0: decode FUNCT7 {
292 0x0: addw({{
293 Rd_sd = Rs1_sw + Rs2_sw;
294 }});
295 0x1: mulw({{
296 Rd_sd = (int32_t)(Rs1_sw*Rs2_sw);
297 }}, IntMultOp);
208 0x20: subw({{
209 Rd_sd = Rs1_sw - Rs2_sw;
210 }});
211 }
212 0x1: sllw({{
213 Rd_sd = Rs1_sw << Rs2<4:0>;
214 }});
298 0x20: subw({{
299 Rd_sd = Rs1_sw - Rs2_sw;
300 }});
301 }
302 0x1: sllw({{
303 Rd_sd = Rs1_sw << Rs2<4:0>;
304 }});
305 0x4: divw({{
306 if (Rs2_sw == 0) {
307 Rd_sd = -1;
308 } else if (Rs1_sw == std::numeric_limits<int32_t>::min()
309 && Rs2_sw == -1) {
310 Rd_sd = std::numeric_limits<int32_t>::min();
311 } else {
312 Rd_sd = Rs1_sw/Rs2_sw;
313 }
314 }}, IntDivOp);
215 0x5: decode FUNCT7 {
216 0x0: srlw({{
217 Rd_uw = Rs1_uw >> Rs2<4:0>;
218 }});
315 0x5: decode FUNCT7 {
316 0x0: srlw({{
317 Rd_uw = Rs1_uw >> Rs2<4:0>;
318 }});
319 0x1: divuw({{
320 if (Rs2_uw == 0) {
321 Rd_sd = std::numeric_limits<IntReg>::max();
322 } else {
323 Rd_sd = (int32_t)(Rs1_uw/Rs2_uw);
324 }
325 }}, IntDivOp);
219 0x20: sraw({{
220 Rd_sd = Rs1_sw >> Rs2<4:0>;
221 }});
222 }
326 0x20: sraw({{
327 Rd_sd = Rs1_sw >> Rs2<4:0>;
328 }});
329 }
330 0x6: remw({{
331 if (Rs2_sw == 0) {
332 Rd_sd = Rs1_sw;
333 } else if (Rs1_sw == std::numeric_limits<int32_t>::min()
334 && Rs2_sw == -1) {
335 Rd_sd = 0;
336 } else {
337 Rd_sd = Rs1_sw%Rs2_sw;
338 }
339 }}, IntDivOp);
340 0x7: remuw({{
341 if (Rs2_uw == 0) {
342 Rd_sd = (int32_t)Rs1_uw;
343 } else {
344 Rd_sd = (int32_t)(Rs1_uw%Rs2_uw);
345 }
346 }}, IntDivOp);
223 }
224 }
225
226 0x63: decode FUNCT3 {
227 format SBOp {
228 0x0: beq({{
229 if (Rs1 == Rs2) {
230 NPC = PC + imm;

--- 102 unchanged lines hidden --- 		347 }
348 }
349
350 0x63: decode FUNCT3 {
351 format SBOp {
352 0x0: beq({{
353 if (Rs1 == Rs2) {
354 NPC = PC + imm;

--- 102 unchanged lines hidden ---