OLD | NEW |
1 :option:::insn-bit-size:16 | 1 :option:::insn-bit-size:16 |
2 :option:::hi-bit-nr:15 | 2 :option:::hi-bit-nr:15 |
3 | 3 |
4 | 4 |
5 :option:::format-names:I,II,III,IV,V,VI,VII,VIII,IX,X | 5 :option:::format-names:I,II,III,IV,V,VI,VII,VIII,IX,X |
6 :option:::format-names:XI,XII,XIII | 6 :option:::format-names:XI,XII,XIII |
7 :option:::format-names:XIV,XV | 7 :option:::format-names:XIV,XV |
8 :option:::format-names:Z | 8 :option:::format-names:Z |
| 9 :option:::format-names:F_I |
9 | 10 |
10 | 11 |
11 :model:::v850:v850: | 12 :model:::v850:v850: |
12 | 13 |
13 :option:::multi-sim:true | 14 :option:::multi-sim:true |
14 :model:::v850e:v850e: | 15 :model:::v850e:v850e: |
15 :option:::multi-sim:true | 16 :option:::multi-sim:true |
16 :model:::v850e1:v850e1: | 17 :model:::v850e1:v850e1: |
| 18 :option:::multi-sim:true |
| 19 :model:::v850e2:v850e2: |
| 20 :option:::multi-sim:true |
| 21 :model:::v850e2v3:v850e2v3: |
17 | 22 |
18 // Cache macros | 23 // Cache macros |
19 | 24 |
20 :cache:::unsigned:reg1:RRRRR:(RRRRR) | 25 :cache:::unsigned:reg1:RRRRR:(RRRRR) |
21 :cache:::unsigned:reg2:rrrrr:(rrrrr) | 26 :cache:::unsigned:reg2:rrrrr:(rrrrr) |
22 :cache:::unsigned:reg3:wwwww:(wwwww) | 27 :cache:::unsigned:reg3:wwwww:(wwwww) |
| 28 :cache:::unsigned:reg4:W,WWWW:((W << 4) + WWWW) |
| 29 |
| 30 :cache:::unsigned:reg1e:RRRR:(RRRR << 1) |
| 31 :cache:::unsigned:reg2e:rrrr:(rrrr << 1) |
| 32 :cache:::unsigned:reg3e:wwww:(wwww << 1) |
| 33 :cache:::unsigned:reg4e:mmmm:(mmmm << 1) |
23 | 34 |
24 :cache:::unsigned:disp4:dddd:(dddd) | 35 :cache:::unsigned:disp4:dddd:(dddd) |
25 :cache:::unsigned:disp5:dddd:(dddd << 1) | 36 :cache:::unsigned:disp5:dddd:(dddd << 1) |
26 :cache:::unsigned:disp7:ddddddd:ddddddd | 37 :cache:::unsigned:disp7:ddddddd:ddddddd |
27 :cache:::unsigned:disp8:ddddddd:(ddddddd << 1) | 38 :cache:::unsigned:disp8:ddddddd:(ddddddd << 1) |
28 :cache:::unsigned:disp8:dddddd:(dddddd << 2) | 39 :cache:::unsigned:disp8:dddddd:(dddddd << 2) |
29 :cache:::unsigned:disp9:ddddd,ddd:SEXT32 ((ddddd << 4) + (ddd << 1), 9 - 1) | 40 :cache:::unsigned:disp9:ddddd,ddd:SEXT32 ((ddddd << 4) + (ddd << 1), 9 - 1) |
30 :cache:::unsigned:disp16:dddddddddddddddd:EXTEND16 (dddddddddddddddd) | 41 :cache:::unsigned:disp16:dddddddddddddddd:EXTEND16 (dddddddddddddddd) |
31 :cache:::unsigned:disp16:ddddddddddddddd: EXTEND16 (ddddddddddddddd << 1) | 42 :cache:::unsigned:disp16:ddddddddddddddd: EXTEND16 (ddddddddddddddd << 1) |
| 43 :cache:::unsigned:disp17:d,ddddddddddddddd:SEXT32 (((d <<16) + (ddddddddddddddd
<< 1)), 17 - 1) |
32 :cache:::unsigned:disp22:dddddd,ddddddddddddddd: SEXT32 ((dddddd << 16) + (ddddd
dddddddddd << 1), 22 - 1) | 44 :cache:::unsigned:disp22:dddddd,ddddddddddddddd: SEXT32 ((dddddd << 16) + (ddddd
dddddddddd << 1), 22 - 1) |
| 45 :cache:::unsigned:disp23:ddddddd,dddddddddddddddd: SEXT32 ((ddddddd) + (dddddddd
dddddddd << 7), 23 - 1) |
| 46 :cache:::unsigned:disp23:dddddd,dddddddddddddddd: SEXT32 ((dddddd << 1) + (ddddd
ddddddddddd << 7), 23 - 1) |
33 | 47 |
34 :cache:::unsigned:imm5:iiiii:SEXT32 (iiiii, 4) | 48 :cache:::unsigned:imm5:iiiii:SEXT32 (iiiii, 4) |
35 :cache:::unsigned:imm6:iiiiii:iiiiii | 49 :cache:::unsigned:imm6:iiiiii:iiiiii |
36 :cache:::unsigned:imm9:iiiii,IIII:SEXT ((IIII << 5) + iiiii, 9 - 1) | 50 :cache:::unsigned:imm9:iiiii,IIII:SEXT ((IIII << 5) + iiiii, 9 - 1) |
37 :cache:::unsigned:imm5:iiii:(32 - (iiii << 1)) | 51 :cache:::unsigned:imm5:iiii:(32 - (iiii << 1)) |
38 :cache:::unsigned:simm16:iiiiiiiiiiiiiiii:EXTEND16 (iiiiiiiiiiiiiiii) | 52 :cache:::unsigned:simm16:iiiiiiiiiiiiiiii:EXTEND16 (iiiiiiiiiiiiiiii) |
39 :cache:::unsigned:uimm16:iiiiiiiiiiiiiiii:iiiiiiiiiiiiiiii | 53 :cache:::unsigned:uimm16:iiiiiiiiiiiiiiii:iiiiiiiiiiiiiiii |
40 :cache:::unsigned:imm32:iiiiiiiiiiiiiiii,IIIIIIIIIIIIIIII:(iiiiiiiiiiiiiiii < 16
+ IIIIIIIIIIIIIIII) | 54 :cache:::unsigned:imm32:iiiiiiiiiiiiiiii,IIIIIIIIIIIIIIII:(iiiiiiiiiiiiiiii < 16
+ IIIIIIIIIIIIIIII) |
41 :cache:::unsigned:uimm32:iiiiiiiiiiiiiiii,dddddddddddddddd:((iiiiiiiiiiiiiiii <<
16) + dddddddddddddddd) | 55 :cache:::unsigned:uimm32:iiiiiiiiiiiiiiii,dddddddddddddddd:((iiiiiiiiiiiiiiii <<
16) + dddddddddddddddd) |
42 | 56 |
43 :cache:::unsigned:vector:iiiii:iiiii | 57 :cache:::unsigned:vector:iiiii:iiiii |
44 | 58 |
45 :cache:::unsigned:list12:L,LLLLLLLLLLL:((L << 11) + LLLLLLLLLLL) | 59 :cache:::unsigned:list12:L,LLLLLLLLLLL:((L << 11) + LLLLLLLLLLL) |
46 :cache:::unsigned:list18:LLLL,LLLLLLLLLLLL:((LLLL << 12) + LLLLLLLLLLLL) | 60 :cache:::unsigned:list18:LLLL,LLLLLLLLLLLL:((LLLL << 12) + LLLLLLLLLLLL) |
47 | 61 |
48 :cache:::unsigned:bit3:bbb:bbb | 62 :cache:::unsigned:bit3:bbb:bbb |
| 63 :cache:::unsigned:bit4:bbbb:bbbb |
49 | 64 |
50 | 65 |
51 // What do we do with an illegal instruction? | 66 // What do we do with an illegal instruction? |
52 :internal::::illegal: | 67 :internal::::illegal: |
53 { | 68 { |
54 sim_io_eprintf (SD, "Illegal instruction at address 0x%lx\n", | 69 sim_io_eprintf (SD, "Illegal instruction at address 0x%lx\n", |
55 (unsigned long) cia); | 70 (unsigned long) cia); |
56 sim_engine_halt (SD, CPU, NULL, cia, sim_signalled, SIM_SIGILL); | 71 sim_engine_halt (SD, CPU, NULL, cia, sim_signalled, SIM_SIGILL); |
57 } | 72 } |
58 | 73 |
59 | 74 |
60 | 75 |
61 // Add | 76 // ADD |
62 | |
63 rrrrr,001110,RRRRR:I:::add | 77 rrrrr,001110,RRRRR:I:::add |
64 "add r<reg1>, r<reg2>" | 78 "add r<reg1>, r<reg2>" |
65 { | 79 { |
66 COMPAT_1 (OP_1C0 ()); | 80 COMPAT_1 (OP_1C0 ()); |
67 } | 81 } |
68 | 82 |
69 rrrrr,010010,iiiii:II:::add | 83 rrrrr,010010,iiiii:II:::add |
70 "add <imm5>,r<reg2>" | 84 "add <imm5>,r<reg2>" |
71 { | 85 { |
72 COMPAT_1 (OP_240 ()); | 86 COMPAT_1 (OP_240 ()); |
73 } | 87 } |
74 | 88 |
75 | 89 |
76 | 90 |
77 // ADDI | 91 // ADDI |
78 rrrrr,110000,RRRRR + iiiiiiiiiiiiiiii:VI:::addi | 92 rrrrr,110000,RRRRR + iiiiiiiiiiiiiiii:VI:::addi |
79 "addi <simm16>, r<reg1>, r<reg2>" | 93 "addi <simm16>, r<reg1>, r<reg2>" |
80 { | 94 { |
81 COMPAT_2 (OP_600 ()); | 95 COMPAT_2 (OP_600 ()); |
82 } | 96 } |
83 | 97 |
84 | 98 |
85 | 99 |
| 100 // ADF |
| 101 rrrrr,111111,RRRRR + wwwww,011101,cccc!13,0:XI:::adf |
| 102 *v850e2 |
| 103 *v850e2v3 |
| 104 "adf %s<cccc>, r<reg1>, r<reg2>, r<reg3>" |
| 105 { |
| 106 int cond = condition_met (cccc); |
| 107 TRACE_ALU_INPUT3 (cond, GR[reg1], GR[reg2]); |
| 108 GR[reg3] = GR[reg1] + GR[reg2] + (cond ? 1 : 0); |
| 109 TRACE_ALU_RESULT1 (GR[reg3]); |
| 110 } |
| 111 |
| 112 |
| 113 |
86 // AND | 114 // AND |
87 rrrrr,001010,RRRRR:I:::and | 115 rrrrr,001010,RRRRR:I:::and |
88 "and r<reg1>, r<reg2>" | 116 "and r<reg1>, r<reg2>" |
89 { | 117 { |
90 COMPAT_1 (OP_140 ()); | 118 COMPAT_1 (OP_140 ()); |
91 } | 119 } |
92 | 120 |
93 | 121 |
94 | 122 |
95 // ANDI | 123 // ANDI |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
146 // Special case - treat "br *" like illegal instruction | 174 // Special case - treat "br *" like illegal instruction |
147 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP); | 175 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP); |
148 } else { | 176 } else { |
149 cond = condition_met (cccc); | 177 cond = condition_met (cccc); |
150 if (cond) | 178 if (cond) |
151 nia = cia + disp9; | 179 nia = cia + disp9; |
152 TRACE_BRANCH1 (cond); | 180 TRACE_BRANCH1 (cond); |
153 } | 181 } |
154 } | 182 } |
155 | 183 |
| 184 00000111111,d,cccc + ddddddddddddddd,1:VII:::Bcond |
| 185 "breakpoint":((disp17 == 0) && (cccc == 0x05)) |
| 186 "b%s<cccc> <disp17>" |
| 187 *v850e2v3 |
| 188 { |
| 189 int cond; |
| 190 cond = condition_met (cccc); |
| 191 if (cond) |
| 192 nia = cia + disp17; |
| 193 TRACE_BRANCH_INPUT1 (cond); |
| 194 TRACE_BRANCH_RESULT (nia); |
| 195 } |
| 196 |
156 | 197 |
157 | 198 |
158 // BSH | 199 // BSH |
159 rrrrr,11111100000 + wwwww,01101000010:XII:::bsh | 200 rrrrr,11111100000 + wwwww,01101000010:XII:::bsh |
160 *v850e | 201 *v850e |
161 *v850e1 | 202 *v850e1 |
| 203 *v850e2 |
| 204 *v850e2v3 |
162 "bsh r<reg2>, r<reg3>" | 205 "bsh r<reg2>, r<reg3>" |
163 { | 206 { |
164 unsigned32 value; | 207 unsigned32 value; |
165 TRACE_ALU_INPUT1 (GR[reg2]); | 208 TRACE_ALU_INPUT1 (GR[reg2]); |
166 | 209 |
167 value = (MOVED32 (GR[reg2], 23, 16, 31, 24) | 210 value = (MOVED32 (GR[reg2], 23, 16, 31, 24) |
168 | MOVED32 (GR[reg2], 31, 24, 23, 16) | 211 | MOVED32 (GR[reg2], 31, 24, 23, 16) |
169 | MOVED32 (GR[reg2], 7, 0, 15, 8) | 212 | MOVED32 (GR[reg2], 7, 0, 15, 8) |
170 | MOVED32 (GR[reg2], 15, 8, 7, 0)); | 213 | MOVED32 (GR[reg2], 15, 8, 7, 0)); |
171 | 214 |
172 GR[reg3] = value; | 215 GR[reg3] = value; |
173 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV); | 216 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV); |
174 if ((value & 0xffff) == 0) PSW |= PSW_Z; | 217 if ((value & 0xffff) == 0) PSW |= PSW_Z; |
175 if (value & 0x80000000) PSW |= PSW_S; | 218 if (value & 0x80000000) PSW |= PSW_S; |
176 if (((value & 0xff) == 0) || ((value & 0xff00) == 0)) PSW |= PSW_CY; | 219 if (((value & 0xff) == 0) || ((value & 0xff00) == 0)) PSW |= PSW_CY; |
177 | 220 |
178 TRACE_ALU_RESULT (GR[reg3]); | 221 TRACE_ALU_RESULT (GR[reg3]); |
179 } | 222 } |
180 | 223 |
| 224 |
| 225 |
181 // BSW | 226 // BSW |
182 rrrrr,11111100000 + wwwww,01101000000:XII:::bsw | 227 rrrrr,11111100000 + wwwww,01101000000:XII:::bsw |
183 *v850e | 228 *v850e |
184 *v850e1 | 229 *v850e1 |
| 230 *v850e2 |
| 231 *v850e2v3 |
185 "bsw r<reg2>, r<reg3>" | 232 "bsw r<reg2>, r<reg3>" |
186 { | 233 { |
187 #define WORDHASNULLBYTE(x) (((x) - 0x01010101) & ~(x)&0x80808080) | 234 #define WORDHASNULLBYTE(x) (((x) - 0x01010101) & ~(x)&0x80808080) |
188 unsigned32 value; | 235 unsigned32 value; |
189 TRACE_ALU_INPUT1 (GR[reg2]); | 236 TRACE_ALU_INPUT1 (GR[reg2]); |
190 | 237 |
191 value = GR[reg2]; | 238 value = GR[reg2]; |
192 value >>= 24; | 239 value >>= 24; |
193 value |= (GR[reg2] << 24); | 240 value |= (GR[reg2] << 24); |
194 value |= ((GR[reg2] << 8) & 0x00ff0000); | 241 value |= ((GR[reg2] << 8) & 0x00ff0000); |
195 value |= ((GR[reg2] >> 8) & 0x0000ff00); | 242 value |= ((GR[reg2] >> 8) & 0x0000ff00); |
196 GR[reg3] = value; | 243 GR[reg3] = value; |
197 | 244 |
198 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV); | 245 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV); |
199 | 246 |
200 if (value == 0) PSW |= PSW_Z; | 247 if (value == 0) PSW |= PSW_Z; |
201 if (value & 0x80000000) PSW |= PSW_S; | 248 if (value & 0x80000000) PSW |= PSW_S; |
202 if (WORDHASNULLBYTE (value)) PSW |= PSW_CY; | 249 if (WORDHASNULLBYTE (value)) PSW |= PSW_CY; |
203 | 250 |
204 TRACE_ALU_RESULT (GR[reg3]); | 251 TRACE_ALU_RESULT (GR[reg3]); |
205 } | 252 } |
206 | 253 |
| 254 |
| 255 |
207 // CALLT | 256 // CALLT |
208 0000001000,iiiiii:II:::callt | 257 0000001000,iiiiii:II:::callt |
209 *v850e | 258 *v850e |
210 *v850e1 | 259 *v850e1 |
| 260 *v850e2 |
| 261 *v850e2v3 |
211 "callt <imm6>" | 262 "callt <imm6>" |
212 { | 263 { |
213 unsigned32 adr; | 264 unsigned32 adr; |
214 unsigned32 off; | 265 unsigned32 off; |
215 CTPC = cia + 2; | 266 CTPC = cia + 2; |
216 CTPSW = PSW; | 267 CTPSW = PSW; |
217 adr = (CTBP & ~1) + (imm6 << 1); | 268 adr = (CTBP & ~1) + (imm6 << 1); |
218 off = load_mem (adr, 2) & ~1; /* Force alignment */ | 269 off = load_mem (adr, 2) & ~1; /* Force alignment */ |
219 nia = (CTBP & ~1) + off; | 270 nia = (CTBP & ~1) + off; |
220 TRACE_BRANCH3 (adr, CTBP, off); | 271 TRACE_BRANCH3 (adr, CTBP, off); |
221 } | 272 } |
222 | 273 |
223 | 274 |
| 275 |
| 276 // CAXI |
| 277 rrrrr,111111,RRRRR + wwwww,00011101110:IX:::caxi |
| 278 *v850e2 |
| 279 *v850e2v3 |
| 280 "caxi [reg1], reg2, reg3" |
| 281 { |
| 282 unsigned int z,s,cy,ov; |
| 283 unsigned32 addr; |
| 284 unsigned32 token,result; |
| 285 |
| 286 addr = GR[reg1]; |
| 287 |
| 288 if (mpu_load_mem_test(sd, addr, 4, reg1) |
| 289 && mpu_store_mem_test(sd, addr, 4, reg1)) |
| 290 { |
| 291 token = load_data_mem (sd, addr, 4); |
| 292 |
| 293 TRACE_ALU_INPUT2 (token, GR[reg2]); |
| 294 |
| 295 result = GR[reg2] - token; |
| 296 |
| 297 z = (result == 0); |
| 298 s = (result & 0x80000000); |
| 299 cy = (GR[reg2] < token); |
| 300 ov = ((GR[reg2] & 0x80000000) != (token & 0x80000000) |
| 301 && (GR[reg2] & 0x80000000) != (result & 0x80000000)); |
| 302 |
| 303 if (result == 0) |
| 304 { |
| 305 store_data_mem (sd, addr, 4, GR[reg3]); |
| 306 GR[reg3] = token; |
| 307 } |
| 308 else |
| 309 { |
| 310 store_data_mem (sd, addr, 4, token); |
| 311 GR[reg3] = token; |
| 312 } |
| 313 |
| 314 /* Set condition codes. */ |
| 315 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV); |
| 316 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0) |
| 317 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)); |
| 318 |
| 319 TRACE_ALU_RESULT1 (GR[reg3]); |
| 320 } |
| 321 } |
| 322 |
| 323 |
224 // CLR1 | 324 // CLR1 |
225 10,bbb,111110,RRRRR + dddddddddddddddd:VIII:::clr1 | 325 10,bbb,111110,RRRRR + dddddddddddddddd:VIII:::clr1 |
226 "clr1 <bit3>, <disp16>[r<reg1>]" | 326 "clr1 <bit3>, <disp16>[r<reg1>]" |
227 { | 327 { |
228 COMPAT_2 (OP_87C0 ()); | 328 COMPAT_2 (OP_87C0 ()); |
229 } | 329 } |
230 | 330 |
231 rrrrr,111111,RRRRR + 0000000011100100:IX:::clr1 | 331 rrrrr,111111,RRRRR + 0000000011100100:IX:::clr1 |
232 *v850e | 332 *v850e |
233 *v850e1 | 333 *v850e1 |
| 334 *v850e2 |
| 335 *v850e2v3 |
234 "clr1 r<reg2>, [r<reg1>]" | 336 "clr1 r<reg2>, [r<reg1>]" |
235 { | 337 { |
236 COMPAT_2 (OP_E407E0 ()); | 338 COMPAT_2 (OP_E407E0 ()); |
237 } | 339 } |
238 | 340 |
239 | 341 |
| 342 |
240 // CTRET | 343 // CTRET |
241 0000011111100000 + 0000000101000100:X:::ctret | 344 0000011111100000 + 0000000101000100:X:::ctret |
242 *v850e | 345 *v850e |
243 *v850e1 | 346 *v850e1 |
| 347 *v850e2 |
| 348 *v850e2v3 |
244 "ctret" | 349 "ctret" |
245 { | 350 { |
246 nia = (CTPC & ~1); | 351 nia = (CTPC & ~1); |
247 PSW = (CTPSW & (CPU)->psw_mask); | 352 PSW = (CTPSW & (CPU)->psw_mask); |
248 TRACE_BRANCH1 (PSW); | 353 TRACE_BRANCH1 (PSW); |
249 } | 354 } |
250 | 355 |
| 356 |
| 357 |
251 // CMOV | 358 // CMOV |
252 rrrrr,111111,RRRRR + wwwww,011001,cccc,0:XI:::cmov | 359 rrrrr,111111,RRRRR + wwwww,011001,cccc,0:XI:::cmov |
253 *v850e | 360 *v850e |
254 *v850e1 | 361 *v850e1 |
| 362 *v850e2 |
| 363 *v850e2v3 |
255 "cmov %s<cccc>, r<reg1>, r<reg2>, r<reg3>" | 364 "cmov %s<cccc>, r<reg1>, r<reg2>, r<reg3>" |
256 { | 365 { |
257 int cond = condition_met (cccc); | 366 int cond = condition_met (cccc); |
258 TRACE_ALU_INPUT3 (cond, GR[reg1], GR[reg2]); | 367 TRACE_ALU_INPUT3 (cond, GR[reg1], GR[reg2]); |
259 GR[reg3] = cond ? GR[reg1] : GR[reg2]; | 368 GR[reg3] = cond ? GR[reg1] : GR[reg2]; |
260 TRACE_ALU_RESULT (GR[reg3]); | 369 TRACE_ALU_RESULT (GR[reg3]); |
261 } | 370 } |
262 | 371 |
263 rrrrr,111111,iiiii + wwwww,011000,cccc,0:XII:::cmov | 372 rrrrr,111111,iiiii + wwwww,011000,cccc,0:XII:::cmov |
264 *v850e | 373 *v850e |
265 *v850e1 | 374 *v850e1 |
| 375 *v850e2 |
| 376 *v850e2v3 |
266 "cmov %s<cccc>, <imm5>, r<reg2>, r<reg3>" | 377 "cmov %s<cccc>, <imm5>, r<reg2>, r<reg3>" |
267 { | 378 { |
268 int cond = condition_met (cccc); | 379 int cond = condition_met (cccc); |
269 TRACE_ALU_INPUT3 (cond, imm5, GR[reg2]); | 380 TRACE_ALU_INPUT3 (cond, imm5, GR[reg2]); |
270 GR[reg3] = cond ? imm5 : GR[reg2]; | 381 GR[reg3] = cond ? imm5 : GR[reg2]; |
271 TRACE_ALU_RESULT (GR[reg3]); | 382 TRACE_ALU_RESULT (GR[reg3]); |
272 } | 383 } |
273 | 384 |
| 385 |
| 386 |
274 // CMP | 387 // CMP |
275 rrrrr,001111,RRRRR:I:::cmp | 388 rrrrr,001111,RRRRR:I:::cmp |
276 "cmp r<reg1>, r<reg2>" | 389 "cmp r<reg1>, r<reg2>" |
277 { | 390 { |
278 COMPAT_1 (OP_1E0 ()); | 391 COMPAT_1 (OP_1E0 ()); |
279 } | 392 } |
280 | 393 |
281 rrrrr,010011,iiiii:II:::cmp | 394 rrrrr,010011,iiiii:II:::cmp |
282 "cmp <imm5>, r<reg2>" | 395 "cmp <imm5>, r<reg2>" |
283 { | 396 { |
(...skipping 10 matching lines...) Expand all Loading... |
294 } | 407 } |
295 | 408 |
296 | 409 |
297 | 410 |
298 // DISPOSE | 411 // DISPOSE |
299 // 0000011001,iiiii,L + LLLLLLLLLLL,00000:XIII:::dispose | 412 // 0000011001,iiiii,L + LLLLLLLLLLL,00000:XIII:::dispose |
300 // "dispose <imm5>, <list12>" | 413 // "dispose <imm5>, <list12>" |
301 0000011001,iiiii,L + LLLLLLLLLLL,RRRRR:XIII:::dispose | 414 0000011001,iiiii,L + LLLLLLLLLLL,RRRRR:XIII:::dispose |
302 *v850e | 415 *v850e |
303 *v850e1 | 416 *v850e1 |
| 417 *v850e2 |
| 418 *v850e2v3 |
304 "dispose <imm5>, <list12>":RRRRR == 0 | 419 "dispose <imm5>, <list12>":RRRRR == 0 |
305 "dispose <imm5>, <list12>, [reg1]" | 420 "dispose <imm5>, <list12>, [reg1]" |
306 { | 421 { |
307 int i; | 422 int i; |
308 SAVE_2; | 423 SAVE_2; |
309 | 424 |
310 trace_input ("dispose", OP_PUSHPOP1, 0); | 425 trace_input ("dispose", OP_PUSHPOP1, 0); |
311 | 426 |
312 SP += (OP[3] & 0x3e) << 1; | 427 SP += (OP[3] & 0x3e) << 1; |
313 | 428 |
314 /* Load the registers with lower number registers being retrieved | 429 /* Load the registers with lower number registers being retrieved |
315 from higher addresses. */ | 430 from higher addresses. */ |
316 for (i = 12; i--;) | 431 for (i = 12; i--;) |
317 if ((OP[3] & (1 << type1_regs[ i ]))) | 432 if ((OP[3] & (1 << type1_regs[ i ]))) |
318 { | 433 { |
319 State.regs[ 20 + i ] = load_mem (SP, 4); | 434 State.regs[ 20 + i ] = load_mem (SP, 4); |
320 SP += 4; | 435 SP += 4; |
321 } | 436 } |
322 | 437 |
323 if ((OP[3] & 0x1f0000) != 0) | 438 if ((OP[3] & 0x1f0000) != 0) |
324 { | 439 { |
325 nia = State.regs[ (OP[3] >> 16) & 0x1f]; | 440 nia = State.regs[ (OP[3] >> 16) & 0x1f]; |
326 } | 441 } |
327 | 442 |
328 trace_output (OP_PUSHPOP1); | 443 trace_output (OP_PUSHPOP1); |
329 } | 444 } |
330 | 445 |
331 | 446 |
| 447 |
332 // DIV | 448 // DIV |
333 rrrrr,111111,RRRRR + wwwww,01011000000:XI:::div | 449 rrrrr,111111,RRRRR + wwwww,01011000000:XI:::div |
334 *v850e | 450 *v850e |
335 *v850e1 | 451 *v850e1 |
| 452 *v850e2 |
| 453 *v850e2v3 |
336 "div r<reg1>, r<reg2>, r<reg3>" | 454 "div r<reg1>, r<reg2>, r<reg3>" |
337 { | 455 { |
338 COMPAT_2 (OP_2C007E0 ()); | 456 COMPAT_2 (OP_2C007E0 ()); |
339 } | 457 } |
340 | 458 |
341 | 459 |
342 // DIVH | 460 // DIVH |
343 rrrrr!0,000010,RRRRR!0:I:::divh | 461 rrrrr!0,000010,RRRRR!0:I:::divh |
344 "divh r<reg1>, r<reg2>" | 462 "divh r<reg1>, r<reg2>" |
345 { | 463 { |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
383 | 501 |
384 trace_output (OP_REG_REG); | 502 trace_output (OP_REG_REG); |
385 | 503 |
386 PC += 2; | 504 PC += 2; |
387 nia = PC; | 505 nia = PC; |
388 } | 506 } |
389 | 507 |
390 rrrrr,111111,RRRRR + wwwww,01010000000:XI:::divh | 508 rrrrr,111111,RRRRR + wwwww,01010000000:XI:::divh |
391 *v850e | 509 *v850e |
392 *v850e1 | 510 *v850e1 |
| 511 *v850e2 |
| 512 *v850e2v3 |
393 "divh r<reg1>, r<reg2>, r<reg3>" | 513 "divh r<reg1>, r<reg2>, r<reg3>" |
394 { | 514 { |
395 COMPAT_2 (OP_28007E0 ()); | 515 COMPAT_2 (OP_28007E0 ()); |
396 } | 516 } |
397 | 517 |
398 | 518 |
399 // DIVHU | 519 // DIVHU |
400 rrrrr,111111,RRRRR + wwwww,01010000010:XI:::divhu | 520 rrrrr,111111,RRRRR + wwwww,01010000010:XI:::divhu |
401 *v850e | 521 *v850e |
402 *v850e1 | 522 *v850e1 |
| 523 *v850e2 |
| 524 *v850e2v3 |
403 "divhu r<reg1>, r<reg2>, r<reg3>" | 525 "divhu r<reg1>, r<reg2>, r<reg3>" |
404 { | 526 { |
405 COMPAT_2 (OP_28207E0 ()); | 527 COMPAT_2 (OP_28207E0 ()); |
406 } | 528 } |
407 | 529 |
408 | 530 |
409 // DIVU | 531 // DIVU |
410 rrrrr,111111,RRRRR + wwwww,01011000010:XI:::divu | 532 rrrrr,111111,RRRRR + wwwww,01011000010:XI:::divu |
411 *v850e | 533 *v850e |
412 *v850e1 | 534 *v850e1 |
| 535 *v850e2 |
| 536 *v850e2v3 |
413 "divu r<reg1>, r<reg2>, r<reg3>" | 537 "divu r<reg1>, r<reg2>, r<reg3>" |
414 { | 538 { |
415 COMPAT_2 (OP_2C207E0 ()); | 539 COMPAT_2 (OP_2C207E0 ()); |
416 } | 540 } |
417 | 541 |
418 | 542 |
| 543 // DIVQ |
| 544 rrrrr,111111,RRRRR + wwwww,01011111100:XI:::divq |
| 545 *v850e2 |
| 546 *v850e2v3 |
| 547 "divq r<reg1>, r<reg2>, r<reg3>" |
| 548 { |
| 549 unsigned int quotient; |
| 550 unsigned int remainder; |
| 551 unsigned int divide_by; |
| 552 unsigned int divide_this; |
| 553 |
| 554 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 555 |
| 556 divide_by = GR[reg1]; |
| 557 divide_this = GR[reg2]; |
| 558 v850_div (sd, divide_by, divide_this, "ient, &remainder); |
| 559 GR[reg2] = quotient; |
| 560 GR[reg3] = remainder; |
| 561 |
| 562 TRACE_ALU_RESULT2 (GR[reg2], GR[reg3]); |
| 563 } |
| 564 |
| 565 |
| 566 // DIVQU |
| 567 rrrrr,111111,RRRRR + wwwww,01011111110:XI:::divqu |
| 568 *v850e2 |
| 569 *v850e2v3 |
| 570 "divq r<reg1>, r<reg2>, r<reg3>" |
| 571 { |
| 572 unsigned int quotient; |
| 573 unsigned int remainder; |
| 574 unsigned int divide_by; |
| 575 unsigned int divide_this; |
| 576 |
| 577 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 578 |
| 579 divide_by = GR[reg1]; |
| 580 divide_this = GR[reg2]; |
| 581 v850_divu (sd, divide_by, divide_this, "ient, &remainder); |
| 582 GR[reg2] = quotient; |
| 583 GR[reg3] = remainder; |
| 584 |
| 585 TRACE_ALU_RESULT2 (GR[reg2], GR[reg3]); |
| 586 } |
| 587 |
| 588 |
419 // EI | 589 // EI |
420 1000011111100000 + 0000000101100000:X:::ei | 590 1000011111100000 + 0000000101100000:X:::ei |
421 "ei" | 591 "ei" |
422 { | 592 { |
423 COMPAT_2 (OP_16087E0 ()); | 593 COMPAT_2 (OP_16087E0 ()); |
424 } | 594 } |
425 | 595 |
426 | 596 |
427 | 597 |
| 598 // EIRET |
| 599 0000011111100000 + 0000000101001000:X:::eiret |
| 600 "eiret" |
| 601 *v850e2 |
| 602 *v850e2v3 |
| 603 { |
| 604 TRACE_ALU_INPUT1 (MPM & MPM_AUE); |
| 605 |
| 606 nia = EIPC; /* next PC */ |
| 607 if (MPM & MPM_AUE) |
| 608 { |
| 609 PSW = EIPSW; |
| 610 } |
| 611 else |
| 612 { |
| 613 PSW = (PSW & (PSW_NPV | PSW_DMP | PSW_IMP)) |
| 614 | (EIPSW & ~(PSW_NPV | PSW_DMP | PSW_IMP)); |
| 615 } |
| 616 |
| 617 TRACE_ALU_RESULT1 (PSW); |
| 618 TRACE_BRANCH_RESULT (nia); |
| 619 } |
| 620 |
| 621 |
| 622 |
| 623 // FERET |
| 624 0000011111100000 + 0000000101001010:X:::feret |
| 625 "feret" |
| 626 *v850e2 |
| 627 *v850e2v3 |
| 628 { |
| 629 TRACE_ALU_INPUT1 (MPM & MPM_AUE); |
| 630 |
| 631 nia = FEPC; /* next PC */ |
| 632 if (MPM & MPM_AUE) |
| 633 { |
| 634 PSW = FEPSW; |
| 635 } |
| 636 else |
| 637 { |
| 638 PSW = (PSW & (PSW_NPV | PSW_DMP | PSW_IMP)) |
| 639 | (FEPSW & ~(PSW_NPV | PSW_DMP | PSW_IMP)); |
| 640 } |
| 641 |
| 642 TRACE_ALU_RESULT1 (PSW); |
| 643 TRACE_BRANCH_RESULT (nia); |
| 644 } |
| 645 |
| 646 |
| 647 // FETRAP |
| 648 0,bbbb!0,00001000000:I:::fetrap |
| 649 "fetrap" |
| 650 *v850e2 |
| 651 *v850e2v3 |
| 652 { |
| 653 TRACE_ALU_INPUT0 (); |
| 654 |
| 655 FEPC = PC + 2; |
| 656 FEPSW = PSW; |
| 657 ECR &= ~ECR_FECC; |
| 658 ECR |= (0x30 + bit4) << 16; |
| 659 FEIC = 0x30 + bit4; |
| 660 PSW |= PSW_EP | PSW_ID | PSW_NP; |
| 661 nia = 0x30; /* next PC */ |
| 662 |
| 663 TRACE_ALU_RESULT1 (PSW); |
| 664 TRACE_BRANCH_RESULT (nia); |
| 665 } |
| 666 |
| 667 |
428 // HALT | 668 // HALT |
429 0000011111100000 + 0000000100100000:X:::halt | 669 0000011111100000 + 0000000100100000:X:::halt |
430 "halt" | 670 "halt" |
431 { | 671 { |
432 COMPAT_2 (OP_12007E0 ()); | 672 COMPAT_2 (OP_12007E0 ()); |
433 } | 673 } |
434 | 674 |
435 | 675 |
436 | 676 |
| 677 // HSH |
| 678 rrrrr,11111100000 + wwwww,01101000110:XII:::hsh |
| 679 *v850e2 |
| 680 *v850e2v3 |
| 681 "hsh r<reg2>, r<reg3>" |
| 682 { |
| 683 unsigned32 value; |
| 684 TRACE_ALU_INPUT1 (GR[reg2]); |
| 685 |
| 686 value = 0xffff & GR[reg2]; |
| 687 GR[reg3] = GR[reg2]; |
| 688 |
| 689 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV); |
| 690 |
| 691 if (value == 0) { PSW |= PSW_Z; PSW |= PSW_CY; } |
| 692 if (value & 0x80000000) PSW |= PSW_S; |
| 693 |
| 694 TRACE_ALU_RESULT1 (GR[reg3]); |
| 695 } |
| 696 |
| 697 |
437 // HSW | 698 // HSW |
438 rrrrr,11111100000 + wwwww,01101000100:XII:::hsw | 699 rrrrr,11111100000 + wwwww,01101000100:XII:::hsw |
439 *v850e | 700 *v850e |
440 *v850e1 | 701 *v850e1 |
| 702 *v850e2 |
| 703 *v850e2v3 |
441 "hsw r<reg2>, r<reg3>" | 704 "hsw r<reg2>, r<reg3>" |
442 { | 705 { |
443 unsigned32 value; | 706 unsigned32 value; |
444 TRACE_ALU_INPUT1 (GR[reg2]); | 707 TRACE_ALU_INPUT1 (GR[reg2]); |
445 | 708 |
446 value = GR[reg2]; | 709 value = GR[reg2]; |
447 value >>= 16; | 710 value >>= 16; |
448 value |= (GR[reg2] << 16); | 711 value |= (GR[reg2] << 16); |
449 | 712 |
450 GR[reg3] = value; | 713 GR[reg3] = value; |
(...skipping 11 matching lines...) Expand all Loading... |
462 | 725 |
463 // JARL | 726 // JARL |
464 rrrrr!0,11110,dddddd + ddddddddddddddd,0:V:::jarl | 727 rrrrr!0,11110,dddddd + ddddddddddddddd,0:V:::jarl |
465 "jarl <disp22>, r<reg2>" | 728 "jarl <disp22>, r<reg2>" |
466 { | 729 { |
467 GR[reg2] = nia; | 730 GR[reg2] = nia; |
468 nia = cia + disp22; | 731 nia = cia + disp22; |
469 TRACE_BRANCH1 (GR[reg2]); | 732 TRACE_BRANCH1 (GR[reg2]); |
470 } | 733 } |
471 | 734 |
| 735 00000010111,RRRRR!0 + iiiiiiiiiiiiiiii + IIIIIIIIIIIIIIII:VI:::jarl32 |
| 736 *v850e2 |
| 737 *v850e2v3 |
| 738 "jarl <imm32>, r<reg1>" |
| 739 { |
| 740 GR[reg1] = nia; |
| 741 nia = (cia + imm32) & ~1; |
| 742 |
| 743 TRACE_BRANCH_RESULT (nia); |
| 744 } |
472 | 745 |
473 | 746 |
474 // JMP | 747 // JMP |
475 00000000011,RRRRR:I:::jmp | 748 00000000011,RRRRR:I:::jmp |
476 "jmp [r<reg1>]" | 749 "jmp [r<reg1>]" |
477 { | 750 { |
478 nia = GR[reg1] & ~1; | 751 nia = GR[reg1] & ~1; |
479 TRACE_BRANCH0 (); | 752 TRACE_BRANCH0 (); |
480 } | 753 } |
481 | 754 |
| 755 00000110111,RRRRR + iiiiiiiiiiiiiiii + IIIIIIIIIIIIIIII:VI:::jmp32 |
| 756 *v850e2 |
| 757 *v850e2v3 |
| 758 "jmp <imm32>[r<reg1>]" |
| 759 { |
| 760 nia = (GR[reg1] + imm32) & ~1; |
| 761 |
| 762 TRACE_BRANCH_RESULT (nia); |
| 763 } |
482 | 764 |
483 | 765 |
484 // JR | 766 // JR |
485 0000011110,dddddd + ddddddddddddddd,0:V:::jr | 767 0000011110,dddddd + ddddddddddddddd,0:V:::jr |
486 "jr <disp22>" | 768 "jr <disp22>" |
487 { | 769 { |
488 nia = cia + disp22; | 770 nia = cia + disp22; |
489 TRACE_BRANCH0 (); | 771 TRACE_BRANCH0 (); |
490 } | 772 } |
491 | 773 |
492 | 774 |
| 775 // JR32 |
| 776 00000010111,00000 + iiiiiiiiiiiiiiii + IIIIIIIIIIIIIIII:VI:::jr32 |
| 777 *v850e2 |
| 778 *v850e2v3 |
| 779 "jr <imm32>" |
| 780 { |
| 781 nia = (cia + imm32) & ~1; |
| 782 |
| 783 TRACE_BRANCH_RESULT (nia); |
| 784 } |
| 785 |
493 | 786 |
494 // LD | 787 // LD |
495 rrrrr,111000,RRRRR + dddddddddddddddd:VII:::ld.b | 788 rrrrr,111000,RRRRR + dddddddddddddddd:VII:::ld.b |
496 "ld.b <disp16>[r<reg1>], r<reg2>" | 789 "ld.b <disp16>[r<reg1>], r<reg2>" |
497 { | 790 { |
498 COMPAT_2 (OP_700 ()); | 791 COMPAT_2 (OP_700 ()); |
499 } | 792 } |
500 | 793 |
| 794 00000111100,RRRRR+wwwww,ddddddd,0101+dddddddddddddddd:XIV:::ld.b |
| 795 "ld.b <disp23>[r<reg1>], r<reg3>" |
| 796 *v850e2v3 |
| 797 { |
| 798 unsigned32 addr = GR[reg1] + disp23; |
| 799 unsigned32 result = EXTEND8 (load_data_mem (sd, addr, 1)); |
| 800 GR[reg3] = result; |
| 801 TRACE_LD (addr, result); |
| 802 } |
| 803 |
501 rrrrr,111001,RRRRR + ddddddddddddddd,0:VII:::ld.h | 804 rrrrr,111001,RRRRR + ddddddddddddddd,0:VII:::ld.h |
502 "ld.h <disp16>[r<reg1>], r<reg2>" | 805 "ld.h <disp16>[r<reg1>], r<reg2>" |
503 { | 806 { |
504 COMPAT_2 (OP_720 ()); | 807 COMPAT_2 (OP_720 ()); |
505 } | 808 } |
506 | 809 |
| 810 00000111100,RRRRR+wwwww,dddddd,00111+dddddddddddddddd:XIV:::ld.h |
| 811 *v850e2v3 |
| 812 "ld.h <disp23>[r<reg1>], r<reg3>" |
| 813 { |
| 814 unsigned32 addr = GR[reg1] + disp23; |
| 815 unsigned32 result = EXTEND16 (load_data_mem (sd, addr, 2)); |
| 816 GR[reg3] = result; |
| 817 TRACE_LD (addr, result); |
| 818 } |
| 819 |
507 rrrrr,111001,RRRRR + ddddddddddddddd,1:VII:::ld.w | 820 rrrrr,111001,RRRRR + ddddddddddddddd,1:VII:::ld.w |
508 "ld.w <disp16>[r<reg1>], r<reg2>" | 821 "ld.w <disp16>[r<reg1>], r<reg2>" |
509 { | 822 { |
510 COMPAT_2 (OP_10720 ()); | 823 COMPAT_2 (OP_10720 ()); |
511 } | 824 } |
512 | 825 |
| 826 00000111100,RRRRR+wwwww,dddddd,01001+dddddddddddddddd:XIV:::ld.w |
| 827 *v850e2v3 |
| 828 "ld.w <disp23>[r<reg1>], r<reg3>" |
| 829 { |
| 830 unsigned32 addr = GR[reg1] + disp23; |
| 831 unsigned32 result = load_data_mem (sd, addr, 4); |
| 832 GR[reg3] = result; |
| 833 TRACE_LD (addr, result); |
| 834 } |
| 835 |
513 rrrrr!0,11110,b,RRRRR + ddddddddddddddd,1:VII:::ld.bu | 836 rrrrr!0,11110,b,RRRRR + ddddddddddddddd,1:VII:::ld.bu |
514 *v850e | 837 *v850e |
515 *v850e1 | 838 *v850e1 |
| 839 *v850e2 |
| 840 *v850e2v3 |
516 "ld.bu <disp16>[r<reg1>], r<reg2>" | 841 "ld.bu <disp16>[r<reg1>], r<reg2>" |
517 { | 842 { |
518 COMPAT_2 (OP_10780 ()); | 843 COMPAT_2 (OP_10780 ()); |
519 } | 844 } |
520 | 845 |
| 846 00000111101,RRRRR+wwwww,ddddddd,0101+dddddddddddddddd:XIV:::ld.bu |
| 847 *v850e2v3 |
| 848 "ld.bu <disp23>[r<reg1>], r<reg3>" |
| 849 { |
| 850 unsigned32 addr = GR[reg1] + disp23; |
| 851 unsigned32 result = load_data_mem (sd, addr, 1); |
| 852 GR[reg3] = result; |
| 853 TRACE_LD (addr, result); |
| 854 } |
| 855 |
521 rrrrr!0,111111,RRRRR + ddddddddddddddd,1:VII:::ld.hu | 856 rrrrr!0,111111,RRRRR + ddddddddddddddd,1:VII:::ld.hu |
522 *v850e | 857 *v850e |
523 *v850e1 | 858 *v850e1 |
| 859 *v850e2 |
| 860 *v850e2v3 |
524 "ld.hu <disp16>[r<reg1>], r<reg2>" | 861 "ld.hu <disp16>[r<reg1>], r<reg2>" |
525 { | 862 { |
526 COMPAT_2 (OP_107E0 ()); | 863 COMPAT_2 (OP_107E0 ()); |
527 } | 864 } |
528 | 865 |
| 866 00000111101,RRRRR+wwwww,dddddd,00111+dddddddddddddddd:XIV:::ld.hu |
| 867 *v850e2v3 |
| 868 "ld.hu <disp23>[r<reg1>], r<reg3>" |
| 869 { |
| 870 unsigned32 addr = GR[reg1] + disp23; |
| 871 unsigned32 result = load_data_mem (sd, addr, 2); |
| 872 GR[reg3] = result; |
| 873 TRACE_LD (addr, result); |
| 874 } |
| 875 |
| 876 |
529 | 877 |
530 // LDSR | 878 // LDSR |
531 regID,111111,RRRRR + 0000000000100000:IX:::ldsr | 879 regID,111111,RRRRR + 0000000000100000:IX:::ldsr |
532 "ldsr r<reg1>, s<regID>" | 880 "ldsr r<reg1>, s<regID>" |
533 { | 881 { |
| 882 uint32 sreg = GR[reg1]; |
534 TRACE_ALU_INPUT1 (GR[reg1]); | 883 TRACE_ALU_INPUT1 (GR[reg1]); |
535 | 884 |
536 if (&PSW == &SR[regID]) | 885 if ((idecode_issue == idecode_v850e2_issue |
537 PSW = (GR[reg1] & (CPU)->psw_mask); | 886 || idecode_issue == idecode_v850e2v3_issue) |
| 887 && regID < 28) |
| 888 { |
| 889 int protect_p = (PSW & PSW_NPV) ? 1 : 0; |
| 890 |
| 891 |
| 892 switch (BSEL & 0xffff) |
| 893 » { |
| 894 » case 0x0000: |
| 895 » if ((PSW & PSW_NPV) |
| 896 » && ((regID >= 8 && regID <= 12) |
| 897 » » || (regID >= 22 && regID <= 27) |
| 898 » » || regID == PSW_REGNO)) |
| 899 » { |
| 900 » protect_p = 0; |
| 901 » } |
| 902 » break; |
| 903 » case 0x1000:» /* MPU0 */ |
| 904 » break; |
| 905 » case 0x1001:» /* MPU1 */ |
| 906 » break; |
| 907 » case 0x2000:» /* FPU */ |
| 908 » if ((PSW & PSW_NPV) |
| 909 » && ((/* regID >= 0 && */ regID <= 5) |
| 910 » » || regID == 8 |
| 911 » » || regID == 9 |
| 912 » » || regID == 10 |
| 913 » » || (regID >= 11 && regID <= 26))) |
| 914 » { |
| 915 » protect_p = 0; |
| 916 » } |
| 917 » break; |
| 918 » case 0xff00: |
| 919 » if ((PSW & PSW_NPV) |
| 920 » && (regID == 6 |
| 921 » » || regID == 7 |
| 922 » » || regID == 8 |
| 923 » » || regID == 9 |
| 924 » » || regID == 10 |
| 925 » » || (regID >= 11 && regID <= 15) |
| 926 » » || regID == 18 |
| 927 » » || regID == 19 |
| 928 » » || (regID >= 21 && regID <= 27))) |
| 929 » { |
| 930 » protect_p = 0; |
| 931 » } |
| 932 » break; |
| 933 » case 0xffff: |
| 934 » if ((PSW & PSW_NPV) |
| 935 » && (regID == 6 |
| 936 » » || regID == 7 |
| 937 » » || regID == 8 |
| 938 » » || regID == 9 |
| 939 » » || regID == 10 |
| 940 » » || regID == 11 |
| 941 » » || regID == 12 |
| 942 » » || regID == 15 |
| 943 » » || regID == 18 |
| 944 » » || regID == 19 |
| 945 » » || (regID >= 21 && regID <= 27))) |
| 946 » { |
| 947 » protect_p = 0; |
| 948 » } |
| 949 » break; |
| 950 » } |
| 951 |
| 952 if (!protect_p) |
| 953 » { |
| 954 » switch (BSEL & 0xffff) |
| 955 » { |
| 956 » case 0x0000: |
| 957 » case 0xff00:» /* user0 bank */ |
| 958 » case 0xffff:» /* user1 bank */ |
| 959 » if(regID == PSW_REGNO) |
| 960 » » { |
| 961 » » SR[regID] = sreg & ((PSW & PSW_NPV) ? 0xf : ~0); |
| 962 » » } |
| 963 » else |
| 964 » » { |
| 965 » » SR[regID] = sreg; |
| 966 » » } |
| 967 » break; |
| 968 » case 0x1000: |
| 969 » MPU0_SR[regID] = sreg; |
| 970 » break; |
| 971 » case 0x1001: |
| 972 » if (regID == MPC_REGNO) |
| 973 » » { |
| 974 » » PPC &= ~PPC_PPE; |
| 975 » » SPAL &= ~SPAL_SPE; |
| 976 » » IPA0L &= ~IPA_IPE; |
| 977 » » IPA1L &= ~IPA_IPE; |
| 978 » » IPA2L &= ~IPA_IPE; |
| 979 » » IPA3L &= ~IPA_IPE; |
| 980 » » DPA0L &= ~DPA_DPE; |
| 981 » » DPA1L &= ~DPA_DPE; |
| 982 » » DCC &= ~(DCC_DCE0 | DCC_DCE1); |
| 983 » » } |
| 984 » else |
| 985 » » { |
| 986 » » MPU1_SR[regID] = sreg; |
| 987 » » } |
| 988 » break; |
| 989 » case 0x2000:» /* FPU */ |
| 990 » if (regID == FPST_REGNO) |
| 991 » » { |
| 992 » » unsigned int val = FPSR & ~(FPSR_PR | FPSR_XC | FPSR_XP); |
| 993 » |
| 994 » » val |= ((sreg & FPST_PR) ? FPSR_PR : 0) |
| 995 » » | ((sreg & FPST_XCE) ? FPSR_XCE : 0) |
| 996 » » | ((sreg & FPST_XCV) ? FPSR_XCV : 0) |
| 997 » » | ((sreg & FPST_XCZ) ? FPSR_XCZ : 0) |
| 998 » » | ((sreg & FPST_XCO) ? FPSR_XCO : 0) |
| 999 » » | ((sreg & FPST_XCU) ? FPSR_XCU : 0) |
| 1000 » » | ((sreg & FPST_XCI) ? FPSR_XCI : 0) |
| 1001 » » | ((sreg & FPST_XPV) ? FPSR_XPV : 0) |
| 1002 » » | ((sreg & FPST_XPZ) ? FPSR_XPZ : 0) |
| 1003 » » | ((sreg & FPST_XPO) ? FPSR_XPO : 0) |
| 1004 » » | ((sreg & FPST_XPU) ? FPSR_XPU : 0) |
| 1005 » » | ((sreg & FPST_XPI) ? FPSR_XPI : 0); |
| 1006 » » FPSR = val; |
| 1007 » » } |
| 1008 » else if (regID == FPCFG_REGNO) |
| 1009 » » { |
| 1010 » » unsigned int val = FPSR & ~(FPSR_RM | FPSR_XE); |
| 1011 |
| 1012 » » val |= (((sreg & FPCFG_RM) >> 7) << 18) |
| 1013 » » | ((sreg & FPCFG_XEV) ? FPSR_XEV : 0) |
| 1014 » » | ((sreg & FPCFG_XEZ) ? FPSR_XEZ : 0) |
| 1015 » » | ((sreg & FPCFG_XEO) ? FPSR_XEO : 0) |
| 1016 » » | ((sreg & FPCFG_XEU) ? FPSR_XEU : 0) |
| 1017 » » | ((sreg & FPCFG_XEI) ? FPSR_XEI : 0); |
| 1018 » » FPSR = val; |
| 1019 » » } |
| 1020 |
| 1021 » FPU_SR[regID] = sreg; |
| 1022 » break; |
| 1023 » } |
| 1024 » } |
| 1025 } |
538 else | 1026 else |
539 SR[regID] = GR[reg1]; | 1027 { |
| 1028 SR[regID] = sreg; |
| 1029 } |
| 1030 |
| 1031 TRACE_ALU_RESULT (sreg); |
| 1032 } |
| 1033 |
| 1034 |
| 1035 |
| 1036 // MAC |
| 1037 rrrrr,111111,RRRRR + wwww,0011110,mmmm,0:XI:::mac |
| 1038 *v850e2 |
| 1039 *v850e2v3 |
| 1040 "mac r<reg1>, r<reg2>, r<reg3e>, r<reg4e>" |
| 1041 { |
| 1042 unsigned long op0; |
| 1043 unsigned long op1; |
| 1044 unsigned long op2; |
| 1045 unsigned long op2hi; |
| 1046 unsigned long lo; |
| 1047 unsigned long mid1; |
| 1048 unsigned long mid2; |
| 1049 unsigned long hi; |
| 1050 unsigned long RdLo; |
| 1051 unsigned long RdHi; |
| 1052 int carry; |
| 1053 bfd_boolean sign; |
| 1054 |
| 1055 op0 = GR[reg1]; |
| 1056 op1 = GR[reg2]; |
| 1057 op2 = GR[reg3e]; |
| 1058 op2hi = GR[reg3e+1]; |
| 1059 |
| 1060 TRACE_ALU_INPUT4 (op0, op1, op2, op2hi); |
| 1061 |
| 1062 sign = (op0 ^ op1) & 0x80000000; |
| 1063 » |
| 1064 if (((signed long) op0) < 0) |
| 1065 op0 = - op0; |
| 1066 » |
| 1067 if (((signed long) op1) < 0) |
| 1068 op1 = - op1; |
| 1069 |
| 1070 /* We can split the 32x32 into four 16x16 operations. This ensures |
| 1071 that we do not lose precision on 32bit only hosts: */ |
| 1072 lo = ( (op0 & 0xFFFF) * (op1 & 0xFFFF)); |
| 1073 mid1 = ( (op0 & 0xFFFF) * ((op1 >> 16) & 0xFFFF)); |
| 1074 mid2 = (((op0 >> 16) & 0xFFFF) * (op1 & 0xFFFF)); |
| 1075 hi = (((op0 >> 16) & 0xFFFF) * ((op1 >> 16) & 0xFFFF)); |
540 | 1076 |
541 TRACE_ALU_RESULT (SR[regID]); | 1077 /* We now need to add all of these results together, taking care |
542 } | 1078 to propogate the carries from the additions: */ |
543 | 1079 RdLo = Add32 (lo, (mid1 << 16), & carry); |
544 | 1080 RdHi = carry; |
| 1081 RdLo = Add32 (RdLo, (mid2 << 16), & carry); |
| 1082 RdHi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi); |
| 1083 |
| 1084 if (sign) |
| 1085 { |
| 1086 RdLo = ~ RdLo; |
| 1087 RdHi = ~ RdHi; |
| 1088 if (RdLo == 0xFFFFFFFF) |
| 1089 » { |
| 1090 » RdLo = 0; |
| 1091 » RdHi += 1; |
| 1092 » } |
| 1093 else |
| 1094 » RdLo += 1; |
| 1095 } |
| 1096 |
| 1097 RdLo = Add32 (RdLo, op2, & carry); |
| 1098 RdHi += carry + op2hi; |
| 1099 |
| 1100 /* Store the result and condition codes. */ |
| 1101 GR[reg4e] = RdLo; |
| 1102 GR[reg4e + 1 ] = RdHi; |
| 1103 |
| 1104 TRACE_ALU_RESULT2 (RdLo, RdHi); |
| 1105 } |
| 1106 |
| 1107 |
| 1108 |
| 1109 // MACU |
| 1110 rrrrr,111111,RRRRR + wwww,0011111,mmmm,0:XI:::macu |
| 1111 *v850e2 |
| 1112 *v850e2v3 |
| 1113 "macu r<reg1>, r<reg2>, r<reg3e>, r<reg4e>" |
| 1114 { |
| 1115 unsigned long op0; |
| 1116 unsigned long op1; |
| 1117 unsigned long op2; |
| 1118 unsigned long op2hi; |
| 1119 unsigned long lo; |
| 1120 unsigned long mid1; |
| 1121 unsigned long mid2; |
| 1122 unsigned long hi; |
| 1123 unsigned long RdLo; |
| 1124 unsigned long RdHi; |
| 1125 int carry; |
| 1126 |
| 1127 op0 = GR[reg1]; |
| 1128 op1 = GR[reg2]; |
| 1129 op2 = GR[reg3e]; |
| 1130 op2hi = GR[reg3e + 1]; |
| 1131 |
| 1132 TRACE_ALU_INPUT4 (op0, op1, op2, op2hi); |
| 1133 |
| 1134 /* We can split the 32x32 into four 16x16 operations. This ensures |
| 1135 that we do not lose precision on 32bit only hosts: */ |
| 1136 lo = ( (op0 & 0xFFFF) * (op1 & 0xFFFF)); |
| 1137 mid1 = ( (op0 & 0xFFFF) * ((op1 >> 16) & 0xFFFF)); |
| 1138 mid2 = (((op0 >> 16) & 0xFFFF) * (op1 & 0xFFFF)); |
| 1139 hi = (((op0 >> 16) & 0xFFFF) * ((op1 >> 16) & 0xFFFF)); |
| 1140 |
| 1141 /* We now need to add all of these results together, taking care |
| 1142 to propogate the carries from the additions: */ |
| 1143 RdLo = Add32 (lo, (mid1 << 16), & carry); |
| 1144 RdHi = carry; |
| 1145 RdLo = Add32 (RdLo, (mid2 << 16), & carry); |
| 1146 RdHi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi); |
| 1147 |
| 1148 RdLo = Add32 (RdLo, op2, & carry); |
| 1149 RdHi += carry + op2hi; |
| 1150 |
| 1151 /* Store the result and condition codes. */ |
| 1152 GR[reg4e] = RdLo; |
| 1153 GR[reg4e+1] = RdHi; |
| 1154 |
| 1155 TRACE_ALU_RESULT2 (RdLo, RdHi); |
| 1156 } |
| 1157 |
| 1158 |
545 | 1159 |
546 // MOV | 1160 // MOV |
547 rrrrr!0,000000,RRRRR:I:::mov | 1161 rrrrr!0,000000,RRRRR:I:::mov |
548 "mov r<reg1>, r<reg2>" | 1162 "mov r<reg1>, r<reg2>" |
549 { | 1163 { |
550 TRACE_ALU_INPUT0 (); | 1164 TRACE_ALU_INPUT0 (); |
551 GR[reg2] = GR[reg1]; | 1165 GR[reg2] = GR[reg1]; |
552 TRACE_ALU_RESULT (GR[reg2]); | 1166 TRACE_ALU_RESULT (GR[reg2]); |
553 } | 1167 } |
554 | 1168 |
555 | |
556 rrrrr!0,010000,iiiii:II:::mov | 1169 rrrrr!0,010000,iiiii:II:::mov |
557 "mov <imm5>, r<reg2>" | 1170 "mov <imm5>, r<reg2>" |
558 { | 1171 { |
559 COMPAT_1 (OP_200 ()); | 1172 COMPAT_1 (OP_200 ()); |
560 } | 1173 } |
561 | 1174 |
562 00000110001,RRRRR + iiiiiiiiiiiiiiii + IIIIIIIIIIIIIIII:VI:::mov | 1175 00000110001,RRRRR + iiiiiiiiiiiiiiii + IIIIIIIIIIIIIIII:VI:::mov |
563 *v850e | 1176 *v850e |
564 *v850e1 | 1177 *v850e1 |
| 1178 *v850e2 |
| 1179 *v850e2v3 |
565 "mov <imm32>, r<reg1>" | 1180 "mov <imm32>, r<reg1>" |
566 { | 1181 { |
567 SAVE_2; | 1182 SAVE_2; |
568 trace_input ("mov", OP_IMM_REG, 4); | 1183 trace_input ("mov", OP_IMM_REG, 4); |
569 State.regs[ OP[0] ] = load_mem (PC + 2, 4); | 1184 State.regs[ OP[0] ] = load_mem (PC + 2, 4); |
570 trace_output (OP_IMM_REG); | 1185 trace_output (OP_IMM_REG); |
571 } | 1186 } |
572 | 1187 |
573 | 1188 |
574 | 1189 |
(...skipping 14 matching lines...) Expand all Loading... |
589 { | 1204 { |
590 COMPAT_2 (OP_640 ()); | 1205 COMPAT_2 (OP_640 ()); |
591 } | 1206 } |
592 | 1207 |
593 | 1208 |
594 | 1209 |
595 // MUL | 1210 // MUL |
596 rrrrr,111111,RRRRR + wwwww,01000100000:XI:::mul | 1211 rrrrr,111111,RRRRR + wwwww,01000100000:XI:::mul |
597 *v850e | 1212 *v850e |
598 *v850e1 | 1213 *v850e1 |
| 1214 *v850e2 |
| 1215 *v850e2v3 |
599 "mul r<reg1>, r<reg2>, r<reg3>" | 1216 "mul r<reg1>, r<reg2>, r<reg3>" |
600 { | 1217 { |
601 COMPAT_2 (OP_22007E0 ()); | 1218 COMPAT_2 (OP_22007E0 ()); |
602 } | 1219 } |
603 | 1220 |
604 rrrrr,111111,iiiii + wwwww,01001,IIII,00:XII:::mul | 1221 rrrrr,111111,iiiii + wwwww,01001,IIII,00:XII:::mul |
605 *v850e | 1222 *v850e |
606 *v850e1 | 1223 *v850e1 |
| 1224 *v850e2 |
| 1225 *v850e2v3 |
607 "mul <imm9>, r<reg2>, r<reg3>" | 1226 "mul <imm9>, r<reg2>, r<reg3>" |
608 { | 1227 { |
609 COMPAT_2 (OP_24007E0 ()); | 1228 COMPAT_2 (OP_24007E0 ()); |
610 } | 1229 } |
611 | 1230 |
612 | 1231 |
613 // MULH | 1232 // MULH |
614 rrrrr!0,000111,RRRRR:I:::mulh | 1233 rrrrr!0,000111,RRRRR:I:::mulh |
615 "mulh r<reg1>, r<reg2>" | 1234 "mulh r<reg1>, r<reg2>" |
616 { | 1235 { |
(...skipping 14 matching lines...) Expand all Loading... |
631 { | 1250 { |
632 COMPAT_2 (OP_6E0 ()); | 1251 COMPAT_2 (OP_6E0 ()); |
633 } | 1252 } |
634 | 1253 |
635 | 1254 |
636 | 1255 |
637 // MULU | 1256 // MULU |
638 rrrrr,111111,RRRRR + wwwww,01000100010:XI:::mulu | 1257 rrrrr,111111,RRRRR + wwwww,01000100010:XI:::mulu |
639 *v850e | 1258 *v850e |
640 *v850e1 | 1259 *v850e1 |
| 1260 *v850e2 |
| 1261 *v850e2v3 |
641 "mulu r<reg1>, r<reg2>, r<reg3>" | 1262 "mulu r<reg1>, r<reg2>, r<reg3>" |
642 { | 1263 { |
643 COMPAT_2 (OP_22207E0 ()); | 1264 COMPAT_2 (OP_22207E0 ()); |
644 } | 1265 } |
645 | 1266 |
646 rrrrr,111111,iiiii + wwwww,01001,IIII,10:XII:::mulu | 1267 rrrrr,111111,iiiii + wwwww,01001,IIII,10:XII:::mulu |
647 *v850e | 1268 *v850e |
648 *v850e1 | 1269 *v850e1 |
| 1270 *v850e2 |
| 1271 *v850e2v3 |
649 "mulu <imm9>, r<reg2>, r<reg3>" | 1272 "mulu <imm9>, r<reg2>, r<reg3>" |
650 { | 1273 { |
651 COMPAT_2 (OP_24207E0 ()); | 1274 COMPAT_2 (OP_24207E0 ()); |
652 } | 1275 } |
653 | 1276 |
654 | 1277 |
655 | 1278 |
656 // NOP | 1279 // NOP |
657 0000000000000000:I:::nop | 1280 0000000000000000:I:::nop |
658 "nop" | 1281 "nop" |
(...skipping 15 matching lines...) Expand all Loading... |
674 // NOT1 | 1297 // NOT1 |
675 01,bbb,111110,RRRRR + dddddddddddddddd:VIII:::not1 | 1298 01,bbb,111110,RRRRR + dddddddddddddddd:VIII:::not1 |
676 "not1 <bit3>, <disp16>[r<reg1>]" | 1299 "not1 <bit3>, <disp16>[r<reg1>]" |
677 { | 1300 { |
678 COMPAT_2 (OP_47C0 ()); | 1301 COMPAT_2 (OP_47C0 ()); |
679 } | 1302 } |
680 | 1303 |
681 rrrrr,111111,RRRRR + 0000000011100010:IX:::not1 | 1304 rrrrr,111111,RRRRR + 0000000011100010:IX:::not1 |
682 *v850e | 1305 *v850e |
683 *v850e1 | 1306 *v850e1 |
| 1307 *v850e2 |
| 1308 *v850e2v3 |
684 "not1 r<reg2>, r<reg1>" | 1309 "not1 r<reg2>, r<reg1>" |
685 { | 1310 { |
686 COMPAT_2 (OP_E207E0 ()); | 1311 COMPAT_2 (OP_E207E0 ()); |
687 } | 1312 } |
688 | 1313 |
689 | 1314 |
690 | 1315 |
691 // OR | 1316 // OR |
692 rrrrr,001000,RRRRR:I:::or | 1317 rrrrr,001000,RRRRR:I:::or |
693 "or r<reg1>, r<reg2>" | 1318 "or r<reg1>, r<reg2>" |
694 { | 1319 { |
695 COMPAT_1 (OP_100 ()); | 1320 COMPAT_1 (OP_100 ()); |
696 } | 1321 } |
697 | 1322 |
698 | 1323 |
699 | 1324 |
700 // ORI | 1325 // ORI |
701 rrrrr,110100,RRRRR + iiiiiiiiiiiiiiii:VI:::ori | 1326 rrrrr,110100,RRRRR + iiiiiiiiiiiiiiii:VI:::ori |
702 "ori <uimm16>, r<reg1>, r<reg2>" | 1327 "ori <uimm16>, r<reg1>, r<reg2>" |
703 { | 1328 { |
704 COMPAT_2 (OP_680 ()); | 1329 COMPAT_2 (OP_680 ()); |
705 } | 1330 } |
706 | 1331 |
707 | 1332 |
708 | 1333 |
709 // PREPARE | 1334 // PREPARE |
710 0000011110,iiiii,L + LLLLLLLLLLL,00001:XIII:::prepare | 1335 0000011110,iiiii,L + LLLLLLLLLLL,00001:XIII:::prepare |
711 *v850e | 1336 *v850e |
712 *v850e1 | 1337 *v850e1 |
| 1338 *v850e2 |
| 1339 *v850e2v3 |
713 "prepare <list12>, <imm5>" | 1340 "prepare <list12>, <imm5>" |
714 { | 1341 { |
715 int i; | 1342 int i; |
716 SAVE_2; | 1343 SAVE_2; |
717 | 1344 |
718 trace_input ("prepare", OP_PUSHPOP1, 0); | 1345 trace_input ("prepare", OP_PUSHPOP1, 0); |
719 | 1346 |
720 /* Store the registers with lower number registers being placed at | 1347 /* Store the registers with lower number registers being placed at |
721 higher addresses. */ | 1348 higher addresses. */ |
722 for (i = 0; i < 12; i++) | 1349 for (i = 0; i < 12; i++) |
723 if ((OP[3] & (1 << type1_regs[ i ]))) | 1350 if ((OP[3] & (1 << type1_regs[ i ]))) |
724 { | 1351 { |
725 SP -= 4; | 1352 SP -= 4; |
726 store_mem (SP, 4, State.regs[ 20 + i ]); | 1353 store_mem (SP, 4, State.regs[ 20 + i ]); |
727 } | 1354 } |
728 | 1355 |
729 SP -= (OP[3] & 0x3e) << 1; | 1356 SP -= (OP[3] & 0x3e) << 1; |
730 | 1357 |
731 trace_output (OP_PUSHPOP1); | 1358 trace_output (OP_PUSHPOP1); |
732 } | 1359 } |
733 | 1360 |
734 | 1361 |
735 0000011110,iiiii,L + LLLLLLLLLLL,00011:XIII:::prepare00 | 1362 0000011110,iiiii,L + LLLLLLLLLLL,00011:XIII:::prepare00 |
736 *v850e | 1363 *v850e |
737 *v850e1 | 1364 *v850e1 |
| 1365 *v850e2 |
| 1366 *v850e2v3 |
738 "prepare <list12>, <imm5>, sp" | 1367 "prepare <list12>, <imm5>, sp" |
739 { | 1368 { |
740 COMPAT_2 (OP_30780 ()); | 1369 COMPAT_2 (OP_30780 ()); |
741 } | 1370 } |
742 | 1371 |
743 0000011110,iiiii,L + LLLLLLLLLLL,01011 + iiiiiiiiiiiiiiii:XIII:::prepare01 | 1372 0000011110,iiiii,L + LLLLLLLLLLL,01011 + iiiiiiiiiiiiiiii:XIII:::prepare01 |
744 *v850e | 1373 *v850e |
745 *v850e1 | 1374 *v850e1 |
| 1375 *v850e2 |
| 1376 *v850e2v3 |
746 "prepare <list12>, <imm5>, <uimm16>" | 1377 "prepare <list12>, <imm5>, <uimm16>" |
747 { | 1378 { |
748 COMPAT_2 (OP_B0780 ()); | 1379 COMPAT_2 (OP_B0780 ()); |
749 } | 1380 } |
750 | 1381 |
751 0000011110,iiiii,L + LLLLLLLLLLL,10011 + iiiiiiiiiiiiiiii:XIII:::prepare10 | 1382 0000011110,iiiii,L + LLLLLLLLLLL,10011 + iiiiiiiiiiiiiiii:XIII:::prepare10 |
752 *v850e | 1383 *v850e |
753 *v850e1 | 1384 *v850e1 |
| 1385 *v850e2 |
| 1386 *v850e2v3 |
754 "prepare <list12>, <imm5>, <uimm16>" | 1387 "prepare <list12>, <imm5>, <uimm16>" |
755 { | 1388 { |
756 COMPAT_2 (OP_130780 ()); | 1389 COMPAT_2 (OP_130780 ()); |
757 } | 1390 } |
758 | 1391 |
759 0000011110,iiiii,L + LLLLLLLLLLL,11011 + iiiiiiiiiiiiiiii + dddddddddddddddd:XII
I:::prepare11 | 1392 0000011110,iiiii,L + LLLLLLLLLLL,11011 + iiiiiiiiiiiiiiii + dddddddddddddddd:XII
I:::prepare11 |
760 *v850e | 1393 *v850e |
761 *v850e1 | 1394 *v850e1 |
| 1395 *v850e2 |
| 1396 *v850e2v3 |
762 "prepare <list12>, <imm5>, <uimm32>" | 1397 "prepare <list12>, <imm5>, <uimm32>" |
763 { | 1398 { |
764 COMPAT_2 (OP_1B0780 ()); | 1399 COMPAT_2 (OP_1B0780 ()); |
765 } | 1400 } |
766 | 1401 |
767 | 1402 |
768 | 1403 |
769 // RETI | 1404 // RETI |
770 0000011111100000 + 0000000101000000:X:::reti | 1405 0000011111100000 + 0000000101000000:X:::reti |
771 "reti" | 1406 "reti" |
(...skipping 24 matching lines...) Expand all Loading... |
796 { | 1431 { |
797 COMPAT_2 (OP_A007E0 ()); | 1432 COMPAT_2 (OP_A007E0 ()); |
798 } | 1433 } |
799 | 1434 |
800 rrrrr,010101,iiiii:II:::sar | 1435 rrrrr,010101,iiiii:II:::sar |
801 "sar <imm5>, r<reg2>" | 1436 "sar <imm5>, r<reg2>" |
802 { | 1437 { |
803 COMPAT_1 (OP_2A0 ()); | 1438 COMPAT_1 (OP_2A0 ()); |
804 } | 1439 } |
805 | 1440 |
| 1441 rrrrr,111111,RRRRR + wwwww,00010100010:XI:::sar |
| 1442 *v850e2 |
| 1443 *v850e2v3 |
| 1444 "sar r<reg1>, r<reg2>, r<reg3>" |
| 1445 { |
| 1446 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 1447 v850_sar(sd, GR[reg1], GR[reg2], &GR[reg3]); |
| 1448 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1449 } |
806 | 1450 |
807 | 1451 |
808 // SASF | 1452 // SASF |
809 rrrrr,1111110,cccc + 0000001000000000:IX:::sasf | 1453 rrrrr,1111110,cccc + 0000001000000000:IX:::sasf |
810 *v850e | 1454 *v850e |
811 *v850e1 | 1455 *v850e1 |
| 1456 *v850e2 |
| 1457 *v850e2v3 |
812 "sasf %s<cccc>, r<reg2>" | 1458 "sasf %s<cccc>, r<reg2>" |
813 { | 1459 { |
814 COMPAT_2 (OP_20007E0 ()); | 1460 COMPAT_2 (OP_20007E0 ()); |
815 } | 1461 } |
816 | 1462 |
817 | 1463 |
818 | 1464 |
819 | |
820 // SATADD | 1465 // SATADD |
821 rrrrr!0,000110,RRRRR:I:::satadd | 1466 rrrrr!0,000110,RRRRR:I:::satadd |
822 "satadd r<reg1>, r<reg2>" | 1467 "satadd r<reg1>, r<reg2>" |
823 { | 1468 { |
824 COMPAT_1 (OP_C0 ()); | 1469 COMPAT_1 (OP_C0 ()); |
825 } | 1470 } |
826 | 1471 |
827 rrrrr!0,010001,iiiii:II:::satadd | 1472 rrrrr!0,010001,iiiii:II:::satadd |
828 "satadd <imm5>, r<reg2>" | 1473 "satadd <imm5>, r<reg2>" |
829 { | 1474 { |
830 COMPAT_1 (OP_220 ()); | 1475 COMPAT_1 (OP_220 ()); |
831 } | 1476 } |
832 | 1477 |
| 1478 rrrrr,111111,RRRRR + wwwww,01110111010:XI:::satadd |
| 1479 *v850e2 |
| 1480 *v850e2v3 |
| 1481 "satadd r<reg1>, r<reg2>, r<reg3>" |
| 1482 { |
| 1483 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 1484 v850_satadd (sd, GR[reg1], GR[reg2], &GR[reg3]); |
| 1485 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1486 } |
| 1487 |
833 | 1488 |
834 | 1489 |
835 // SATSUB | 1490 // SATSUB |
836 rrrrr!0,000101,RRRRR:I:::satsub | 1491 rrrrr!0,000101,RRRRR:I:::satsub |
837 "satsub r<reg1>, r<reg2>" | 1492 "satsub r<reg1>, r<reg2>" |
838 { | 1493 { |
839 COMPAT_1 (OP_A0 ()); | 1494 COMPAT_1 (OP_A0 ()); |
840 } | 1495 } |
841 | 1496 |
| 1497 rrrrr,111111,RRRRR + wwwww,01110011010:XI:::satsub |
| 1498 *v850e2 |
| 1499 *v850e2v3 |
| 1500 "satsub r<reg1>, r<reg2>, r<reg3>" |
| 1501 { |
| 1502 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 1503 v850_satsub (sd, GR[reg1], GR[reg2], &GR[reg3]); |
| 1504 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1505 } |
| 1506 |
842 | 1507 |
843 | 1508 |
844 // SATSUBI | 1509 // SATSUBI |
845 rrrrr!0,110011,RRRRR + iiiiiiiiiiiiiiii:VI:::satsubi | 1510 rrrrr!0,110011,RRRRR + iiiiiiiiiiiiiiii:VI:::satsubi |
846 "satsubi <simm16>, r<reg1>, r<reg2>" | 1511 "satsubi <simm16>, r<reg1>, r<reg2>" |
847 { | 1512 { |
848 COMPAT_2 (OP_660 ()); | 1513 COMPAT_2 (OP_660 ()); |
849 } | 1514 } |
850 | 1515 |
851 | 1516 |
852 | 1517 |
853 // SATSUBR | 1518 // SATSUBR |
854 rrrrr!0,000100,RRRRR:I:::satsubr | 1519 rrrrr!0,000100,RRRRR:I:::satsubr |
855 "satsubr r<reg1>, r<reg2>" | 1520 "satsubr r<reg1>, r<reg2>" |
856 { | 1521 { |
857 COMPAT_1 (OP_80 ()); | 1522 COMPAT_1 (OP_80 ()); |
858 } | 1523 } |
859 | 1524 |
860 | 1525 |
861 | 1526 |
| 1527 //SBF |
| 1528 rrrrr,111111,RRRRR + wwwww,011100,cccc!13,0:XI:::sbf |
| 1529 *v850e2 |
| 1530 *v850e2v3 |
| 1531 "sbf %s<cccc>, r<reg1>, r<reg2>, r<reg3>" |
| 1532 { |
| 1533 int cond = condition_met (cccc); |
| 1534 TRACE_ALU_INPUT3 (cond, GR[reg1], GR[reg2]); |
| 1535 GR[reg3] = GR[reg2] - GR[reg1] - (cond ? 1 : 0); |
| 1536 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1537 } |
| 1538 |
| 1539 |
| 1540 |
| 1541 // SCH0L |
| 1542 rrrrr,11111100000 + wwwww,01101100100:IX:::sch0l |
| 1543 *v850e2 |
| 1544 *v850e2v3 |
| 1545 "sch0l r<reg2>, r<reg3>" |
| 1546 { |
| 1547 unsigned int pos, op0; |
| 1548 |
| 1549 TRACE_ALU_INPUT1 (GR[reg2]); |
| 1550 |
| 1551 op0 = GR[reg2]; |
| 1552 |
| 1553 if (op0 == 0xffffffff) |
| 1554 { |
| 1555 PSW &= ~PSW_CY; |
| 1556 PSW &= ~PSW_OV; |
| 1557 PSW &= ~PSW_S; |
| 1558 PSW |= PSW_Z; |
| 1559 pos = 0; |
| 1560 } |
| 1561 else if (op0 == 0xfffffffe) |
| 1562 { |
| 1563 PSW |= PSW_CY; |
| 1564 PSW &= ~PSW_OV; |
| 1565 PSW &= ~PSW_S; |
| 1566 PSW &= ~PSW_Z; |
| 1567 pos = 32; |
| 1568 } |
| 1569 else |
| 1570 { |
| 1571 pos = 1; |
| 1572 while (op0 & 0x80000000) |
| 1573 { |
| 1574 op0 <<= 1; |
| 1575 pos++; |
| 1576 } |
| 1577 PSW &= ~PSW_CY; |
| 1578 PSW &= ~PSW_OV; |
| 1579 PSW &= ~PSW_S; |
| 1580 PSW &= ~PSW_Z; |
| 1581 } |
| 1582 |
| 1583 GR[reg3] = pos; |
| 1584 |
| 1585 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1586 } |
| 1587 |
| 1588 |
| 1589 |
| 1590 // SCH0R |
| 1591 rrrrr,11111100000 + wwwww,01101100000:IX:::sch0r |
| 1592 *v850e2 |
| 1593 *v850e2v3 |
| 1594 "sch0r r<reg2>, r<reg3>" |
| 1595 { |
| 1596 unsigned int pos, op0; |
| 1597 |
| 1598 TRACE_ALU_INPUT1 (GR[reg2]); |
| 1599 |
| 1600 op0 = GR[reg2]; |
| 1601 |
| 1602 if (op0 == 0xffffffff) |
| 1603 { |
| 1604 PSW &= ~PSW_CY; |
| 1605 PSW &= ~PSW_OV; |
| 1606 PSW &= ~PSW_S; |
| 1607 PSW |= PSW_Z; |
| 1608 pos = 0; |
| 1609 } |
| 1610 else if (op0 == 0x7fffffff) |
| 1611 { |
| 1612 PSW |= PSW_CY; |
| 1613 PSW &= ~PSW_OV; |
| 1614 PSW &= ~PSW_S; |
| 1615 PSW &= ~PSW_Z; |
| 1616 pos = 32; |
| 1617 } |
| 1618 else |
| 1619 { |
| 1620 pos = 1; |
| 1621 while (op0 & 0x00000001) |
| 1622 { |
| 1623 op0 >>= 1; |
| 1624 pos++; |
| 1625 } |
| 1626 PSW &= ~PSW_CY; |
| 1627 PSW &= ~PSW_OV; |
| 1628 PSW &= ~PSW_S; |
| 1629 PSW &= ~PSW_Z; |
| 1630 } |
| 1631 |
| 1632 GR[reg3] = pos; |
| 1633 |
| 1634 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1635 } |
| 1636 |
| 1637 // SCH1L |
| 1638 rrrrr,11111100000 + wwwww,01101100110:IX:::sch1l |
| 1639 *v850e2 |
| 1640 *v850e2v3 |
| 1641 "sch1l r<reg2>, r<reg3>" |
| 1642 { |
| 1643 unsigned int pos, op0; |
| 1644 |
| 1645 TRACE_ALU_INPUT1 (GR[reg2]); |
| 1646 |
| 1647 op0 = GR[reg2]; |
| 1648 |
| 1649 if (op0 == 0x00000000) |
| 1650 { |
| 1651 PSW &= ~PSW_CY; |
| 1652 PSW &= ~PSW_OV; |
| 1653 PSW &= ~PSW_S; |
| 1654 PSW |= PSW_Z; |
| 1655 pos = 0; |
| 1656 } |
| 1657 else if (op0 == 0x00000001) |
| 1658 { |
| 1659 PSW |= PSW_CY; |
| 1660 PSW &= ~PSW_OV; |
| 1661 PSW &= ~PSW_S; |
| 1662 PSW &= ~PSW_Z; |
| 1663 pos = 32; |
| 1664 } |
| 1665 else |
| 1666 { |
| 1667 pos = 1; |
| 1668 while (!(op0 & 0x80000000)) |
| 1669 { |
| 1670 op0 <<= 1; |
| 1671 pos++; |
| 1672 } |
| 1673 PSW &= ~PSW_CY; |
| 1674 PSW &= ~PSW_OV; |
| 1675 PSW &= ~PSW_S; |
| 1676 PSW &= ~PSW_Z; |
| 1677 } |
| 1678 |
| 1679 GR[reg3] = pos; |
| 1680 |
| 1681 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1682 } |
| 1683 |
| 1684 // SCH1R |
| 1685 rrrrr,11111100000 + wwwww,01101100010:IX:::sch1r |
| 1686 *v850e2 |
| 1687 *v850e2v3 |
| 1688 "sch1r r<reg2>, r<reg3>" |
| 1689 { |
| 1690 unsigned int pos, op0; |
| 1691 |
| 1692 TRACE_ALU_INPUT1 (GR[reg2]); |
| 1693 |
| 1694 op0 = GR[reg2]; |
| 1695 |
| 1696 if (op0 == 0x00000000) |
| 1697 { |
| 1698 PSW &= ~PSW_CY; |
| 1699 PSW &= ~PSW_OV; |
| 1700 PSW &= ~PSW_S; |
| 1701 PSW |= PSW_Z; |
| 1702 pos = 0; |
| 1703 } |
| 1704 else if (op0 == 0x80000000) |
| 1705 { |
| 1706 PSW |= PSW_CY; |
| 1707 PSW &= ~PSW_OV; |
| 1708 PSW &= ~PSW_S; |
| 1709 PSW &= ~PSW_Z; |
| 1710 pos = 32; |
| 1711 } |
| 1712 else |
| 1713 { |
| 1714 pos = 1; |
| 1715 while (!(op0 & 0x00000001)) |
| 1716 { |
| 1717 op0 >>= 1; |
| 1718 pos++; |
| 1719 } |
| 1720 PSW &= ~PSW_CY; |
| 1721 PSW &= ~PSW_OV; |
| 1722 PSW &= ~PSW_S; |
| 1723 PSW &= ~PSW_Z; |
| 1724 } |
| 1725 |
| 1726 GR[reg3] = pos; |
| 1727 |
| 1728 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1729 } |
| 1730 |
| 1731 //SHL |
| 1732 rrrrr,111111,RRRRR + wwwww,00011000010:XI:::shl |
| 1733 *v850e2 |
| 1734 *v850e2v3 |
| 1735 "shl r<reg1>, r<reg2>, r<reg3>" |
| 1736 { |
| 1737 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 1738 v850_shl(sd, GR[reg1], GR[reg2], &GR[reg3]); |
| 1739 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1740 } |
| 1741 |
| 1742 //SHR |
| 1743 rrrrr,111111,RRRRR + wwwww,00010000010:XI:::shr |
| 1744 *v850e2 |
| 1745 *v850e2v3 |
| 1746 "shr r<reg1>, r<reg2>, r<reg3>" |
| 1747 { |
| 1748 TRACE_ALU_INPUT2 (GR[reg1], GR[reg2]); |
| 1749 v850_shr(sd, GR[reg1], GR[reg2], &GR[reg3]); |
| 1750 TRACE_ALU_RESULT1 (GR[reg3]); |
| 1751 } |
| 1752 |
| 1753 |
| 1754 |
862 // SETF | 1755 // SETF |
863 rrrrr,1111110,cccc + 0000000000000000:IX:::setf | 1756 rrrrr,1111110,cccc + 0000000000000000:IX:::setf |
864 "setf %s<cccc>, r<reg2>" | 1757 "setf %s<cccc>, r<reg2>" |
865 { | 1758 { |
866 COMPAT_2 (OP_7E0 ()); | 1759 COMPAT_2 (OP_7E0 ()); |
867 } | 1760 } |
868 | 1761 |
869 | 1762 |
870 | 1763 |
871 // SET1 | 1764 // SET1 |
872 00,bbb,111110,RRRRR + dddddddddddddddd:VIII:::set1 | 1765 00,bbb,111110,RRRRR + dddddddddddddddd:VIII:::set1 |
873 "set1 <bit3>, <disp16>[r<reg1>]" | 1766 "set1 <bit3>, <disp16>[r<reg1>]" |
874 { | 1767 { |
875 COMPAT_2 (OP_7C0 ()); | 1768 COMPAT_2 (OP_7C0 ()); |
876 } | 1769 } |
877 | 1770 |
878 rrrrr,111111,RRRRR + 0000000011100000:IX:::set1 | 1771 rrrrr,111111,RRRRR + 0000000011100000:IX:::set1 |
879 *v850e | 1772 *v850e |
880 *v850e1 | 1773 *v850e1 |
| 1774 *v850e2 |
| 1775 *v850e2v3 |
881 "set1 r<reg2>, [r<reg1>]" | 1776 "set1 r<reg2>, [r<reg1>]" |
882 { | 1777 { |
883 COMPAT_2 (OP_E007E0 ()); | 1778 COMPAT_2 (OP_E007E0 ()); |
884 } | 1779 } |
885 | 1780 |
886 | 1781 |
887 | 1782 |
888 // SHL | 1783 // SHL |
889 rrrrr,111111,RRRRR + 0000000011000000:IX:::shl | 1784 rrrrr,111111,RRRRR + 0000000011000000:IX:::shl |
890 "shl r<reg1>, r<reg2>" | 1785 "shl r<reg1>, r<reg2>" |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
959 { | 1854 { |
960 unsigned32 addr = EP + disp8; | 1855 unsigned32 addr = EP + disp8; |
961 unsigned32 result = load_mem (addr, 4); | 1856 unsigned32 result = load_mem (addr, 4); |
962 GR[reg2] = result; | 1857 GR[reg2] = result; |
963 TRACE_LD (addr, result); | 1858 TRACE_LD (addr, result); |
964 } | 1859 } |
965 | 1860 |
966 rrrrr!0,0000110,dddd:IV:::sld.bu | 1861 rrrrr!0,0000110,dddd:IV:::sld.bu |
967 *v850e | 1862 *v850e |
968 *v850e1 | 1863 *v850e1 |
| 1864 *v850e2 |
| 1865 *v850e2v3 |
969 "sld.b <disp4>[ep], r<reg2>":(PSW & PSW_US) | 1866 "sld.b <disp4>[ep], r<reg2>":(PSW & PSW_US) |
970 "sld.bu <disp4>[ep], r<reg2>" | 1867 "sld.bu <disp4>[ep], r<reg2>" |
971 { | 1868 { |
972 unsigned32 addr = EP + disp4; | 1869 unsigned32 addr = EP + disp4; |
973 unsigned32 result = load_mem (addr, 1); | 1870 unsigned32 result = load_mem (addr, 1); |
974 if (PSW & PSW_US) | 1871 if (PSW & PSW_US) |
975 { | 1872 { |
976 result = EXTEND8 (result); | 1873 result = EXTEND8 (result); |
977 GR[reg2] = result; | 1874 GR[reg2] = result; |
978 TRACE_LD_NAME ("sld.b", addr, result); | 1875 TRACE_LD_NAME ("sld.b", addr, result); |
979 } | 1876 } |
980 else | 1877 else |
981 { | 1878 { |
982 GR[reg2] = result; | 1879 GR[reg2] = result; |
983 TRACE_LD (addr, result); | 1880 TRACE_LD (addr, result); |
984 } | 1881 } |
985 } | 1882 } |
986 | 1883 |
987 rrrrr!0,0000111,dddd:IV:::sld.hu | 1884 rrrrr!0,0000111,dddd:IV:::sld.hu |
988 *v850e | 1885 *v850e |
989 *v850e1 | 1886 *v850e1 |
| 1887 *v850e2 |
| 1888 *v850e2v3 |
990 "sld.h <disp5>[ep], r<reg2>":(PSW & PSW_US) | 1889 "sld.h <disp5>[ep], r<reg2>":(PSW & PSW_US) |
991 "sld.hu <disp5>[ep], r<reg2>" | 1890 "sld.hu <disp5>[ep], r<reg2>" |
992 { | 1891 { |
993 unsigned32 addr = EP + disp5; | 1892 unsigned32 addr = EP + disp5; |
994 unsigned32 result = load_mem (addr, 2); | 1893 unsigned32 result = load_mem (addr, 2); |
995 if (PSW & PSW_US) | 1894 if (PSW & PSW_US) |
996 { | 1895 { |
997 result = EXTEND16 (result); | 1896 result = EXTEND16 (result); |
998 GR[reg2] = result; | 1897 GR[reg2] = result; |
999 TRACE_LD_NAME ("sld.h", addr, result); | 1898 TRACE_LD_NAME ("sld.h", addr, result); |
1000 } | 1899 } |
1001 else | 1900 else |
1002 { | 1901 { |
1003 GR[reg2] = result; | 1902 GR[reg2] = result; |
1004 TRACE_LD (addr, result); | 1903 TRACE_LD (addr, result); |
1005 } | 1904 } |
1006 } | 1905 } |
1007 | 1906 |
| 1907 |
| 1908 |
1008 // SST | 1909 // SST |
1009 rrrrr,0111,ddddddd:IV:::sst.b | 1910 rrrrr,0111,ddddddd:IV:::sst.b |
1010 "sst.b r<reg2>, <disp7>[ep]" | 1911 "sst.b r<reg2>, <disp7>[ep]" |
1011 { | 1912 { |
1012 COMPAT_1 (OP_380 ()); | 1913 COMPAT_1 (OP_380 ()); |
1013 } | 1914 } |
1014 | 1915 |
1015 rrrrr,1001,ddddddd:IV:::sst.h | 1916 rrrrr,1001,ddddddd:IV:::sst.h |
1016 "sst.h r<reg2>, <disp8>[ep]" | 1917 "sst.h r<reg2>, <disp8>[ep]" |
1017 { | 1918 { |
1018 COMPAT_1 (OP_480 ()); | 1919 COMPAT_1 (OP_480 ()); |
1019 } | 1920 } |
1020 | 1921 |
1021 rrrrr,1010,dddddd,1:IV:::sst.w | 1922 rrrrr,1010,dddddd,1:IV:::sst.w |
1022 "sst.w r<reg2>, <disp8>[ep]" | 1923 "sst.w r<reg2>, <disp8>[ep]" |
1023 { | 1924 { |
1024 COMPAT_1 (OP_501 ()); | 1925 COMPAT_1 (OP_501 ()); |
1025 } | 1926 } |
1026 | 1927 |
1027 // ST | 1928 // ST |
1028 rrrrr,111010,RRRRR + dddddddddddddddd:VII:::st.b | 1929 rrrrr,111010,RRRRR + dddddddddddddddd:VII:::st.b |
1029 "st.b r<reg2>, <disp16>[r<reg1>]" | 1930 "st.b r<reg2>, <disp16>[r<reg1>]" |
1030 { | 1931 { |
1031 COMPAT_2 (OP_740 ()); | 1932 COMPAT_2 (OP_740 ()); |
1032 } | 1933 } |
1033 | 1934 |
| 1935 00000111100,RRRRR + wwwww,ddddddd,1101 + dddddddddddddddd:XIV:::st.b |
| 1936 *v850e2v3 |
| 1937 "st.b r<reg3>, <disp23>[r<reg1>]" |
| 1938 { |
| 1939 unsigned32 addr = GR[reg1] + disp23; |
| 1940 store_data_mem (sd, addr, 1, GR[reg3]); |
| 1941 TRACE_ST (addr, GR[reg3]); |
| 1942 } |
| 1943 |
1034 rrrrr,111011,RRRRR + ddddddddddddddd,0:VII:::st.h | 1944 rrrrr,111011,RRRRR + ddddddddddddddd,0:VII:::st.h |
1035 "st.h r<reg2>, <disp16>[r<reg1>]" | 1945 "st.h r<reg2>, <disp16>[r<reg1>]" |
1036 { | 1946 { |
1037 COMPAT_2 (OP_760 ()); | 1947 COMPAT_2 (OP_760 ()); |
1038 } | 1948 } |
1039 | 1949 |
| 1950 00000111101,RRRRR+wwwww,dddddd,01101+dddddddddddddddd:XIV:::st.h |
| 1951 *v850e2v3 |
| 1952 "st.h r<reg3>, <disp23>[r<reg1>]" |
| 1953 { |
| 1954 unsigned32 addr = GR[reg1] + disp23; |
| 1955 store_data_mem (sd, addr, 2, GR[reg3]); |
| 1956 TRACE_ST (addr, GR[reg3]); |
| 1957 } |
| 1958 |
1040 rrrrr,111011,RRRRR + ddddddddddddddd,1:VII:::st.w | 1959 rrrrr,111011,RRRRR + ddddddddddddddd,1:VII:::st.w |
1041 "st.w r<reg2>, <disp16>[r<reg1>]" | 1960 "st.w r<reg2>, <disp16>[r<reg1>]" |
1042 { | 1961 { |
1043 COMPAT_2 (OP_10760 ()); | 1962 COMPAT_2 (OP_10760 ()); |
1044 } | 1963 } |
1045 | 1964 |
| 1965 00000111100,RRRRR+wwwww,dddddd,01111+dddddddddddddddd:XIV:::st.w |
| 1966 *v850e2v3 |
| 1967 "st.w r<reg3>, <disp23>[r<reg1>]" |
| 1968 { |
| 1969 unsigned32 addr = GR[reg1] + disp23; |
| 1970 store_data_mem (sd, addr, 4, GR[reg3]); |
| 1971 TRACE_ST (addr, GR[reg3]); |
| 1972 } |
| 1973 |
| 1974 |
1046 // STSR | 1975 // STSR |
1047 rrrrr,111111,regID + 0000000001000000:IX:::stsr | 1976 rrrrr,111111,regID + 0000000001000000:IX:::stsr |
1048 "stsr s<regID>, r<reg2>" | 1977 "stsr s<regID>, r<reg2>" |
1049 { | 1978 { |
1050 TRACE_ALU_INPUT1 (SR[regID]); | 1979 uint32 sreg = 0; |
1051 GR[reg2] = SR[regID]; | 1980 |
| 1981 if ((idecode_issue == idecode_v850e2_issue |
| 1982 || idecode_issue == idecode_v850e2v3_issue) |
| 1983 && regID < 28) |
| 1984 { |
| 1985 switch (BSEL & 0xffff) |
| 1986 » { |
| 1987 » case 0x0000: |
| 1988 » case 0xff00:» /* USER 0 */ |
| 1989 » case 0xffff:» /* USER 1 */ |
| 1990 » sreg = SR[regID]; |
| 1991 » break; |
| 1992 » case 0x1000: |
| 1993 » sreg = MPU0_SR[regID]; |
| 1994 » break; |
| 1995 » case 0x1001: |
| 1996 » sreg = MPU1_SR[regID]; |
| 1997 » break; |
| 1998 » case 0x2000: |
| 1999 » if (regID == FPST_REGNO) |
| 2000 » { |
| 2001 » sreg = ((FPSR & FPSR_PR) ? FPST_PR : 0) |
| 2002 » » | ((FPSR & FPSR_XCE) ? FPST_XCE : 0) |
| 2003 » » | ((FPSR & FPSR_XCV) ? FPST_XCV : 0) |
| 2004 » » | ((FPSR & FPSR_XCZ) ? FPST_XCZ : 0) |
| 2005 » » | ((FPSR & FPSR_XCO) ? FPST_XCO : 0) |
| 2006 » » | ((FPSR & FPSR_XCU) ? FPST_XCU : 0) |
| 2007 » » | ((FPSR & FPSR_XCI) ? FPST_XCI : 0) |
| 2008 » » | ((FPSR & FPSR_XPV) ? FPST_XPV : 0) |
| 2009 » » | ((FPSR & FPSR_XPZ) ? FPST_XPZ : 0) |
| 2010 » » | ((FPSR & FPSR_XPO) ? FPST_XPO : 0) |
| 2011 » » | ((FPSR & FPSR_XPU) ? FPST_XPU : 0) |
| 2012 » » | ((FPSR & FPSR_XPI) ? FPST_XPI : 0); |
| 2013 » } |
| 2014 » else if (regID == FPCFG_REGNO) |
| 2015 » { |
| 2016 » sreg = (((FPSR & FPSR_RM) >> 18) << 7) |
| 2017 » » | ((FPSR & FPSR_XEV) ? FPCFG_XEV : 0) |
| 2018 » » | ((FPSR & FPSR_XEZ) ? FPCFG_XEZ : 0) |
| 2019 » » | ((FPSR & FPSR_XEO) ? FPCFG_XEO : 0) |
| 2020 » » | ((FPSR & FPSR_XEU) ? FPCFG_XEU : 0) |
| 2021 » » | ((FPSR & FPSR_XEI) ? FPCFG_XEI : 0); |
| 2022 » } |
| 2023 » else |
| 2024 » { |
| 2025 » sreg = FPU_SR[regID]; |
| 2026 » } |
| 2027 » break; |
| 2028 » } |
| 2029 } |
| 2030 else |
| 2031 { |
| 2032 sreg = SR[regID]; |
| 2033 } |
| 2034 |
| 2035 TRACE_ALU_INPUT1 (sreg); |
| 2036 GR[reg2] = sreg; |
1052 TRACE_ALU_RESULT (GR[reg2]); | 2037 TRACE_ALU_RESULT (GR[reg2]); |
1053 } | 2038 } |
1054 | 2039 |
1055 // SUB | 2040 // SUB |
1056 rrrrr,001101,RRRRR:I:::sub | 2041 rrrrr,001101,RRRRR:I:::sub |
1057 "sub r<reg1>, r<reg2>" | 2042 "sub r<reg1>, r<reg2>" |
1058 { | 2043 { |
1059 COMPAT_1 (OP_1A0 ()); | 2044 COMPAT_1 (OP_1A0 ()); |
1060 } | 2045 } |
1061 | 2046 |
1062 // SUBR | 2047 // SUBR |
1063 rrrrr,001100,RRRRR:I:::subr | 2048 rrrrr,001100,RRRRR:I:::subr |
1064 "subr r<reg1>, r<reg2>" | 2049 "subr r<reg1>, r<reg2>" |
1065 { | 2050 { |
1066 COMPAT_1 (OP_180 ()); | 2051 COMPAT_1 (OP_180 ()); |
1067 } | 2052 } |
1068 | 2053 |
1069 // SWITCH | 2054 // SWITCH |
1070 00000000010,RRRRR:I:::switch | 2055 00000000010,RRRRR:I:::switch |
1071 *v850e | 2056 *v850e |
1072 *v850e1 | 2057 *v850e1 |
| 2058 *v850e2 |
| 2059 *v850e2v3 |
1073 "switch r<reg1>" | 2060 "switch r<reg1>" |
1074 { | 2061 { |
1075 unsigned long adr; | 2062 unsigned long adr; |
1076 SAVE_1; | 2063 SAVE_1; |
1077 trace_input ("switch", OP_REG, 0); | 2064 trace_input ("switch", OP_REG, 0); |
1078 adr = (cia + 2) + (State.regs[ reg1 ] << 1); | 2065 adr = (cia + 2) + (State.regs[ reg1 ] << 1); |
1079 nia = (cia + 2) + (EXTEND16 (load_mem (adr, 2)) << 1); | 2066 nia = (cia + 2) + (EXTEND16 (load_mem (adr, 2)) << 1); |
1080 trace_output (OP_REG); | 2067 trace_output (OP_REG); |
1081 } | 2068 } |
1082 | 2069 |
1083 // SXB | 2070 // SXB |
1084 00000000101,RRRRR:I:::sxb | 2071 00000000101,RRRRR:I:::sxb |
1085 *v850e | 2072 *v850e |
1086 *v850e1 | 2073 *v850e1 |
| 2074 *v850e2 |
| 2075 *v850e2v3 |
1087 "sxb r<reg1>" | 2076 "sxb r<reg1>" |
1088 { | 2077 { |
1089 TRACE_ALU_INPUT1 (GR[reg1]); | 2078 TRACE_ALU_INPUT1 (GR[reg1]); |
1090 GR[reg1] = EXTEND8 (GR[reg1]); | 2079 GR[reg1] = EXTEND8 (GR[reg1]); |
1091 TRACE_ALU_RESULT (GR[reg1]); | 2080 TRACE_ALU_RESULT (GR[reg1]); |
1092 } | 2081 } |
1093 | 2082 |
1094 // SXH | 2083 // SXH |
1095 00000000111,RRRRR:I:::sxh | 2084 00000000111,RRRRR:I:::sxh |
1096 *v850e | 2085 *v850e |
1097 *v850e1 | 2086 *v850e1 |
| 2087 *v850e2 |
| 2088 *v850e2v3 |
1098 "sxh r<reg1>" | 2089 "sxh r<reg1>" |
1099 { | 2090 { |
1100 TRACE_ALU_INPUT1 (GR[reg1]); | 2091 TRACE_ALU_INPUT1 (GR[reg1]); |
1101 GR[reg1] = EXTEND16 (GR[reg1]); | 2092 GR[reg1] = EXTEND16 (GR[reg1]); |
1102 TRACE_ALU_RESULT (GR[reg1]); | 2093 TRACE_ALU_RESULT (GR[reg1]); |
1103 } | 2094 } |
1104 | 2095 |
1105 // TRAP | 2096 // TRAP |
1106 00000111111,iiiii + 0000000100000000:X:::trap | 2097 00000111111,iiiii + 0000000100000000:X:::trap |
1107 "trap <vector>" | 2098 "trap <vector>" |
(...skipping 11 matching lines...) Expand all Loading... |
1119 // TST1 | 2110 // TST1 |
1120 11,bbb,111110,RRRRR + dddddddddddddddd:VIII:::tst1 | 2111 11,bbb,111110,RRRRR + dddddddddddddddd:VIII:::tst1 |
1121 "tst1 <bit3>, <disp16>[r<reg1>]" | 2112 "tst1 <bit3>, <disp16>[r<reg1>]" |
1122 { | 2113 { |
1123 COMPAT_2 (OP_C7C0 ()); | 2114 COMPAT_2 (OP_C7C0 ()); |
1124 } | 2115 } |
1125 | 2116 |
1126 rrrrr,111111,RRRRR + 0000000011100110:IX:::tst1 | 2117 rrrrr,111111,RRRRR + 0000000011100110:IX:::tst1 |
1127 *v850e | 2118 *v850e |
1128 *v850e1 | 2119 *v850e1 |
| 2120 *v850e2 |
| 2121 *v850e2v3 |
1129 "tst1 r<reg2>, [r<reg1>]" | 2122 "tst1 r<reg2>, [r<reg1>]" |
1130 { | 2123 { |
1131 COMPAT_2 (OP_E607E0 ()); | 2124 COMPAT_2 (OP_E607E0 ()); |
1132 } | 2125 } |
1133 | 2126 |
1134 // XOR | 2127 // XOR |
1135 rrrrr,001001,RRRRR:I:::xor | 2128 rrrrr,001001,RRRRR:I:::xor |
1136 "xor r<reg1>, r<reg2>" | 2129 "xor r<reg1>, r<reg2>" |
1137 { | 2130 { |
1138 COMPAT_1 (OP_120 ()); | 2131 COMPAT_1 (OP_120 ()); |
1139 } | 2132 } |
1140 | 2133 |
1141 // XORI | 2134 // XORI |
1142 rrrrr,110101,RRRRR + iiiiiiiiiiiiiiii:VI:::xori | 2135 rrrrr,110101,RRRRR + iiiiiiiiiiiiiiii:VI:::xori |
1143 "xori <uimm16>, r<reg1>, r<reg2>" | 2136 "xori <uimm16>, r<reg1>, r<reg2>" |
1144 { | 2137 { |
1145 COMPAT_2 (OP_6A0 ()); | 2138 COMPAT_2 (OP_6A0 ()); |
1146 } | 2139 } |
1147 | 2140 |
1148 // ZXB | 2141 // ZXB |
1149 00000000100,RRRRR:I:::zxb | 2142 00000000100,RRRRR:I:::zxb |
1150 *v850e | 2143 *v850e |
1151 *v850e1 | 2144 *v850e1 |
| 2145 *v850e2 |
| 2146 *v850e2v3 |
1152 "zxb r<reg1>" | 2147 "zxb r<reg1>" |
1153 { | 2148 { |
1154 TRACE_ALU_INPUT1 (GR[reg1]); | 2149 TRACE_ALU_INPUT1 (GR[reg1]); |
1155 GR[reg1] = GR[reg1] & 0xff; | 2150 GR[reg1] = GR[reg1] & 0xff; |
1156 TRACE_ALU_RESULT (GR[reg1]); | 2151 TRACE_ALU_RESULT (GR[reg1]); |
1157 } | 2152 } |
1158 | 2153 |
1159 // ZXH | 2154 // ZXH |
1160 00000000110,RRRRR:I:::zxh | 2155 00000000110,RRRRR:I:::zxh |
1161 *v850e | 2156 *v850e |
1162 *v850e1 | 2157 *v850e1 |
| 2158 *v850e2 |
| 2159 *v850e2v3 |
1163 "zxh r<reg1>" | 2160 "zxh r<reg1>" |
1164 { | 2161 { |
1165 TRACE_ALU_INPUT1 (GR[reg1]); | 2162 TRACE_ALU_INPUT1 (GR[reg1]); |
1166 GR[reg1] = GR[reg1] & 0xffff; | 2163 GR[reg1] = GR[reg1] & 0xffff; |
1167 TRACE_ALU_RESULT (GR[reg1]); | 2164 TRACE_ALU_RESULT (GR[reg1]); |
1168 } | 2165 } |
1169 | 2166 |
1170 // Right field must be zero so that it doesn't clash with DIVH | 2167 // Right field must be zero so that it doesn't clash with DIVH |
1171 // Left field must be non-zero so that it doesn't clash with SWITCH | 2168 // Left field must be non-zero so that it doesn't clash with SWITCH |
1172 11111,000010,00000:I:::break | 2169 11111,000010,00000:I:::break |
1173 *v850 | 2170 *v850 |
1174 *v850e | 2171 *v850e |
1175 { | 2172 { |
1176 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP); | 2173 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP); |
1177 } | 2174 } |
1178 | 2175 |
1179 11111,000010,00000:I:::dbtrap | 2176 11111,000010,00000:I:::dbtrap |
1180 *v850e1 | 2177 *v850e1 |
| 2178 *v850e2 |
| 2179 *v850e2v3 |
1181 "dbtrap" | 2180 "dbtrap" |
1182 { | 2181 { |
1183 DBPC = cia + 2; | 2182 DBPC = cia + 2; |
1184 DBPSW = PSW; | 2183 DBPSW = PSW; |
1185 PSW = PSW | (PSW_NP | PSW_EP | PSW_ID); | 2184 PSW = PSW | (PSW_NP | PSW_EP | PSW_ID); |
1186 PC = 0x00000060; | 2185 PC = 0x00000060; |
1187 nia = 0x00000060; | 2186 nia = 0x00000060; |
1188 TRACE_BRANCH0 (); | 2187 TRACE_BRANCH0 (); |
1189 } | 2188 } |
1190 | 2189 |
1191 // New breakpoint: 0x7E0 0x7E0 | 2190 // New breakpoint: 0x7E0 0x7E0 |
1192 00000,111111,00000 + 00000,11111,100000:X:::ilgop | 2191 00000,111111,00000 + 00000,11111,100000:X:::ilgop |
1193 { | 2192 { |
1194 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP); | 2193 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP); |
1195 } | 2194 } |
1196 | 2195 |
1197 // Return from debug trap: 0x146007e0 | 2196 // Return from debug trap: 0x146007e0 |
1198 0000011111100000 + 0000000101000110:X:::dbret | 2197 0000011111100000 + 0000000101000110:X:::dbret |
1199 *v850e1 | 2198 *v850e1 |
| 2199 *v850e2 |
| 2200 *v850e2v3 |
1200 "dbret" | 2201 "dbret" |
1201 { | 2202 { |
1202 nia = DBPC; | 2203 nia = DBPC; |
1203 PSW = DBPSW; | 2204 PSW = DBPSW; |
1204 TRACE_BRANCH1 (PSW); | 2205 TRACE_BRANCH1 (PSW); |
1205 } | 2206 } |
| 2207 |
| 2208 |
| 2209 // |
| 2210 // FLOAT |
| 2211 // |
| 2212 |
| 2213 // Map condition code to a string |
| 2214 :%s::::FFFF:int FFFF |
| 2215 { |
| 2216 switch (FFFF) |
| 2217 { |
| 2218 case 0: return "f"; |
| 2219 case 1: return "un"; |
| 2220 case 2: return "eq"; |
| 2221 case 3: return "ueq"; |
| 2222 case 4: return "olt"; |
| 2223 case 5: return "ult"; |
| 2224 case 6: return "ole"; |
| 2225 case 7: return "ule"; |
| 2226 case 8: return "sf"; |
| 2227 case 9: return "ngle"; |
| 2228 case 10: return "seq"; |
| 2229 case 11: return "ngl"; |
| 2230 case 12: return "lt"; |
| 2231 case 13: return "nge"; |
| 2232 case 14: return "le"; |
| 2233 case 15: return "ngt"; |
| 2234 } |
| 2235 return "(null)"; |
| 2236 } |
| 2237 |
| 2238 // ABSF.D |
| 2239 rrrr,011111100000 + wwww,010001011000:F_I:::absf_d |
| 2240 *v850e2v3 |
| 2241 "absf.d r<reg2e>, r<reg3e>" |
| 2242 { |
| 2243 sim_fpu ans, wop; |
| 2244 sim_fpu_status status; |
| 2245 |
| 2246 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 2247 TRACE_FP_INPUT_FPU1 (&wop); |
| 2248 |
| 2249 status = sim_fpu_abs (&ans, &wop); |
| 2250 check_invalid_snan(sd, status, 1); |
| 2251 |
| 2252 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2253 |
| 2254 TRACE_FP_RESULT_FPU1 (&ans); |
| 2255 } |
| 2256 |
| 2257 // ABSF.S |
| 2258 rrrrr,11111100000 + wwwww,10001001000:F_I:::absf_s |
| 2259 *v850e2v3 |
| 2260 "absf.s r<reg2>, r<reg3>" |
| 2261 { |
| 2262 sim_fpu ans, wop; |
| 2263 sim_fpu_status status; |
| 2264 |
| 2265 sim_fpu_32to (&wop, GR[reg2]); |
| 2266 TRACE_FP_INPUT_FPU1 (&wop); |
| 2267 |
| 2268 status = sim_fpu_abs (&ans, &wop); |
| 2269 check_invalid_snan(sd, status, 0); |
| 2270 |
| 2271 sim_fpu_to32 (&GR[reg3], &ans); |
| 2272 TRACE_FP_RESULT_FPU1 (&ans); |
| 2273 } |
| 2274 |
| 2275 // ADDF.D |
| 2276 rrrr,0111111,RRRR,0 + wwww,010001110000:F_I:::addf_d |
| 2277 *v850e2v3 |
| 2278 "addf.d r<reg1e>, r<reg2e>, r<reg3e>" |
| 2279 { |
| 2280 sim_fpu ans, wop1, wop2; |
| 2281 sim_fpu_status status; |
| 2282 |
| 2283 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2284 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2285 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2286 |
| 2287 status = sim_fpu_add (&ans, &wop1, &wop2); |
| 2288 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2289 |
| 2290 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 1); |
| 2291 |
| 2292 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2293 TRACE_FP_RESULT_FPU1 (&ans); |
| 2294 } |
| 2295 |
| 2296 // ADDF.S |
| 2297 rrrrr,111111,RRRRR + wwwww,10001100000:F_I:::addf_s |
| 2298 *v850e2v3 |
| 2299 "addf.s r<reg1>, r<reg2>, r<reg3>" |
| 2300 { |
| 2301 sim_fpu ans, wop1, wop2; |
| 2302 sim_fpu_status status; |
| 2303 |
| 2304 sim_fpu_32to (&wop1, GR[reg1]); |
| 2305 sim_fpu_32to (&wop2, GR[reg2]); |
| 2306 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2307 |
| 2308 status = sim_fpu_add (&ans, &wop1, &wop2); |
| 2309 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2310 |
| 2311 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 2312 |
| 2313 sim_fpu_to32 (&GR[reg3], &ans); |
| 2314 TRACE_FP_RESULT_FPU1 (&ans); |
| 2315 } |
| 2316 |
| 2317 // CMOVF.D |
| 2318 rrrr,0111111,RRRR,0 + wwww!0,01000001,bbb,0:F_I:::cmovf_d |
| 2319 *v850e2v3 |
| 2320 "cmovf.d <bbb>, r<reg1e>, r<reg2e>, r<reg3e>" |
| 2321 { |
| 2322 unsigned int ophi,oplow; |
| 2323 sim_fpu ans, wop1, wop2; |
| 2324 |
| 2325 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2326 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2327 TRACE_FP_INPUT_BOOL1_FPU2 (TEST_FPCC(bbb), &wop1, &wop2); |
| 2328 |
| 2329 if (TEST_FPCC(bbb)) |
| 2330 { |
| 2331 ophi = GR[reg1e+1]; |
| 2332 oplow = GR[reg1e]; |
| 2333 ans = wop1; |
| 2334 } |
| 2335 else |
| 2336 { |
| 2337 ophi = GR[reg2e+1]; |
| 2338 oplow = GR[reg2e]; |
| 2339 ans = wop2; |
| 2340 } |
| 2341 |
| 2342 GR[reg3e+1] = ophi; |
| 2343 GR[reg3e] = oplow; |
| 2344 TRACE_FP_RESULT_FPU1 (&ans);; |
| 2345 } |
| 2346 |
| 2347 // CMOVF.S |
| 2348 rrrrr,111111,RRRRR + wwwww!0,1000000,bbb,0:F_I:::cmovf_s |
| 2349 *v850e2v3 |
| 2350 "cmovf.d <bbb>, r<reg1>, r<reg2>, r<reg3>" |
| 2351 { |
| 2352 unsigned int op; |
| 2353 sim_fpu ans, wop1, wop2; |
| 2354 |
| 2355 sim_fpu_32to (&wop1, GR[reg1]); |
| 2356 sim_fpu_32to (&wop2, GR[reg2]); |
| 2357 TRACE_FP_INPUT_BOOL1_FPU2 (TEST_FPCC(bbb), &wop1, &wop2); |
| 2358 |
| 2359 if (TEST_FPCC(bbb)) |
| 2360 { |
| 2361 op = GR[reg1]; |
| 2362 ans = wop1; |
| 2363 } |
| 2364 else |
| 2365 { |
| 2366 op = GR[reg2]; |
| 2367 ans = wop2; |
| 2368 } |
| 2369 |
| 2370 GR[reg3] = op; |
| 2371 TRACE_FP_RESULT_FPU1 (&ans); |
| 2372 } |
| 2373 |
| 2374 // CMPF.D |
| 2375 rrrr,0111111,RRRR,0 + 0,FFFF,1000011,bbb,0:F_I:::cmpf_d |
| 2376 *v850e2v3 |
| 2377 "cmpf.d %s<FFFF>, r<reg1e>, r<reg2e>":(bbb == 0) |
| 2378 "cmpf.d %s<FFFF>, r<reg1e>, r<reg2e>, <bbb>" |
| 2379 { |
| 2380 int result; |
| 2381 sim_fpu wop1; |
| 2382 sim_fpu wop2; |
| 2383 |
| 2384 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2385 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2386 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2387 |
| 2388 result = v850_float_compare(sd, FFFF, wop1, wop2, 1); |
| 2389 |
| 2390 if (result) |
| 2391 SET_FPCC(bbb); |
| 2392 else |
| 2393 CLEAR_FPCC(bbb); |
| 2394 |
| 2395 TRACE_FP_RESULT_BOOL (result); |
| 2396 } |
| 2397 |
| 2398 // CMPF.S |
| 2399 rrrrr,111111,RRRRR + 0,FFFF,1000010,bbb,0:F_I:::cmpf_s |
| 2400 *v850e2v3 |
| 2401 "cmpf.s %s<FFFF>, r<reg1>, r<reg2>":(bbb == 0) |
| 2402 "cmpf.s %s<FFFF>, r<reg1>, r<reg2>, <bbb>" |
| 2403 { |
| 2404 int result; |
| 2405 sim_fpu wop1; |
| 2406 sim_fpu wop2; |
| 2407 |
| 2408 sim_fpu_32to( &wop1, GR[reg1] ); |
| 2409 sim_fpu_32to( &wop2, GR[reg2] ); |
| 2410 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2411 |
| 2412 result = v850_float_compare(sd, FFFF, wop1, wop2, 0); |
| 2413 |
| 2414 if (result) |
| 2415 SET_FPCC(bbb); |
| 2416 else |
| 2417 CLEAR_FPCC(bbb); |
| 2418 |
| 2419 TRACE_FP_RESULT_BOOL (result); |
| 2420 } |
| 2421 |
| 2422 // CVTF.DL |
| 2423 rrrr,011111100100 + wwww,010001010100:F_I:::cvtf_dl |
| 2424 *v850e2v3 |
| 2425 "cvtf.dl r<reg2e>, r<reg3e>" |
| 2426 { |
| 2427 unsigned64 ans; |
| 2428 sim_fpu wop; |
| 2429 sim_fpu_status status; |
| 2430 |
| 2431 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 2432 TRACE_FP_INPUT_FPU1 (&wop); |
| 2433 |
| 2434 status = sim_fpu_round_64 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2435 status |= sim_fpu_to64i (&ans, &wop, FPSR_GET_ROUND()); |
| 2436 |
| 2437 check_cvt_fi(sd, status, 1); |
| 2438 |
| 2439 GR[reg3e] = ans; |
| 2440 GR[reg3e+1] = ans>>32L; |
| 2441 TRACE_FP_RESULT_WORD2 (GR[reg3e], GR[reg3e+1]); |
| 2442 } |
| 2443 |
| 2444 // CVTF.DS |
| 2445 rrrr,011111100011 + wwwww,10001010010:F_I:::cvtf_ds |
| 2446 *v850e2v3 |
| 2447 "cvtf.ds r<reg2e>, r<reg3>" |
| 2448 { |
| 2449 sim_fpu wop; |
| 2450 sim_fpu_status status; |
| 2451 |
| 2452 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 2453 TRACE_FP_INPUT_FPU1 (&wop); |
| 2454 |
| 2455 status = sim_fpu_round_32 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_in
exact); |
| 2456 |
| 2457 check_cvt_fi(sd, status, 0); |
| 2458 |
| 2459 sim_fpu_to32 (&GR[reg3], &wop); |
| 2460 TRACE_FP_RESULT_FPU1 (&wop); |
| 2461 } |
| 2462 |
| 2463 // CVTF.DW |
| 2464 rrrr,011111100100 + wwwww,10001010000:F_I:::cvtf_dw |
| 2465 *v850e2v3 |
| 2466 "cvtf.dw r<reg2e>, r<reg3>" |
| 2467 { |
| 2468 uint32 ans; |
| 2469 sim_fpu wop; |
| 2470 sim_fpu_status status; |
| 2471 |
| 2472 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 2473 TRACE_FP_INPUT_FPU1 (&wop); |
| 2474 |
| 2475 status = sim_fpu_round_32 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2476 status |= sim_fpu_to32i (&ans, &wop, FPSR_GET_ROUND()); |
| 2477 |
| 2478 check_cvt_fi(sd, status, 1); |
| 2479 |
| 2480 GR[reg3] = ans; |
| 2481 TRACE_FP_RESULT_WORD1 (ans); |
| 2482 } |
| 2483 |
| 2484 // CVTF.LD |
| 2485 rrrr,011111100001 + wwww,010001010010:F_I:::cvtf_ld |
| 2486 *v850e2v3 |
| 2487 "cvtf.ld r<reg2e>, r<reg3e>" |
| 2488 { |
| 2489 signed64 op; |
| 2490 sim_fpu wop; |
| 2491 sim_fpu_status status; |
| 2492 |
| 2493 op = ((signed64)GR[reg2e+1] << 32L) | GR[reg2e]; |
| 2494 TRACE_FP_INPUT_WORD2 (GR[reg2e], GR[reg2e+1]); |
| 2495 |
| 2496 sim_fpu_i64to (&wop, op, FPSR_GET_ROUND()); |
| 2497 status = sim_fpu_round_64 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2498 |
| 2499 check_cvt_if(sd, status, 1); |
| 2500 |
| 2501 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &wop); |
| 2502 TRACE_FP_RESULT_FPU1 (&wop); |
| 2503 } |
| 2504 |
| 2505 // CVTF.LS |
| 2506 rrrr,011111100001 + wwwww,10001000010:F_I:::cvtf_ls |
| 2507 *v850e2v3 |
| 2508 "cvtf.ls r<reg2e>, r<reg3>" |
| 2509 { |
| 2510 signed64 op; |
| 2511 sim_fpu wop; |
| 2512 sim_fpu_status status; |
| 2513 |
| 2514 op = ((signed64)GR[reg2e+1] << 32L) | GR[reg2e]; |
| 2515 TRACE_FP_INPUT_WORD2 (GR[reg2e], GR[reg2e+1]); |
| 2516 |
| 2517 sim_fpu_i64to (&wop, op, FPSR_GET_ROUND()); |
| 2518 status = sim_fpu_round_32 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2519 |
| 2520 check_cvt_if(sd, status, 0); |
| 2521 |
| 2522 sim_fpu_to32 (&GR[reg3], &wop); |
| 2523 TRACE_FP_RESULT_FPU1 (&wop); |
| 2524 } |
| 2525 |
| 2526 // CVTF.SD |
| 2527 rrrrr,11111100010 + wwww,010001010010:F_I:::cvtf_sd |
| 2528 *v850e2v3 |
| 2529 "cvtf.sd r<reg2>, r<reg3e>" |
| 2530 { |
| 2531 sim_fpu wop; |
| 2532 sim_fpu_status status; |
| 2533 |
| 2534 sim_fpu_32to (&wop, GR[reg2]); |
| 2535 TRACE_FP_INPUT_FPU1 (&wop); |
| 2536 status = sim_fpu_round_64 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_in
exact); |
| 2537 |
| 2538 check_cvt_ff(sd, status, 1); |
| 2539 |
| 2540 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &wop); |
| 2541 TRACE_FP_RESULT_FPU1 (&wop); |
| 2542 } |
| 2543 |
| 2544 // CVTF.SL |
| 2545 rrrrr,11111100100 + wwww,010001000100:F_I:::cvtf_sl |
| 2546 *v850e2v3 |
| 2547 "cvtf.sl r<reg2>, r<reg3e>" |
| 2548 { |
| 2549 signed64 ans; |
| 2550 sim_fpu wop; |
| 2551 sim_fpu_status status; |
| 2552 |
| 2553 sim_fpu_32to (&wop, GR[reg2]); |
| 2554 TRACE_FP_INPUT_FPU1 (&wop); |
| 2555 |
| 2556 status = sim_fpu_round_64 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2557 status |= sim_fpu_to64i (&ans, &wop, FPSR_GET_ROUND()); |
| 2558 |
| 2559 check_cvt_fi(sd, status, 0); |
| 2560 |
| 2561 GR[reg3e] = ans; |
| 2562 GR[reg3e+1] = ans >> 32L; |
| 2563 TRACE_FP_RESULT_WORD2 (GR[reg3e], GR[reg3e+1]); |
| 2564 } |
| 2565 |
| 2566 // CVTF.SW |
| 2567 rrrrr,11111100100 + wwwww,10001000000:F_I:::cvtf_sw |
| 2568 *v850e2v3 |
| 2569 "cvtf.sw r<reg2>, r<reg3>" |
| 2570 { |
| 2571 uint32 ans; |
| 2572 sim_fpu wop; |
| 2573 sim_fpu_status status; |
| 2574 |
| 2575 sim_fpu_32to (&wop, GR[reg2]); |
| 2576 TRACE_FP_INPUT_FPU1 (&wop); |
| 2577 |
| 2578 status = sim_fpu_round_32 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2579 status |= sim_fpu_to32i (&ans, &wop, sim_fpu_round_zero); |
| 2580 |
| 2581 check_cvt_fi(sd, status, 0); |
| 2582 |
| 2583 GR[reg3] = ans; |
| 2584 TRACE_FP_RESULT_WORD1 (ans); |
| 2585 } |
| 2586 |
| 2587 // CVTF.WD |
| 2588 rrrrr,11111100000 + wwww,010001010010:F_I:::cvtf_wd |
| 2589 *v850e2v3 |
| 2590 "cvtf.wd r<reg2>, r<reg3e>" |
| 2591 { |
| 2592 sim_fpu wop; |
| 2593 sim_fpu_status status; |
| 2594 |
| 2595 TRACE_FP_INPUT_WORD1 (GR[reg2]); |
| 2596 sim_fpu_i32to (&wop, GR[reg2], FPSR_GET_ROUND()); |
| 2597 status = sim_fpu_round_64 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2598 |
| 2599 check_cvt_if(sd, status, 1); |
| 2600 |
| 2601 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &wop); |
| 2602 TRACE_FP_RESULT_FPU1 (&wop); |
| 2603 } |
| 2604 |
| 2605 // CVTF.WS |
| 2606 rrrrr,11111100000 + wwwww,10001000010:F_I:::cvtf_ws |
| 2607 *v850e2v3 |
| 2608 "cvtf.ws r<reg2>, r<reg3>" |
| 2609 { |
| 2610 sim_fpu wop; |
| 2611 sim_fpu_status status; |
| 2612 |
| 2613 TRACE_FP_INPUT_WORD1 (GR[reg2]); |
| 2614 sim_fpu_i32to (&wop, GR[reg2], FPSR_GET_ROUND()); |
| 2615 status = sim_fpu_round_32 (&wop, FPSR_GET_ROUND(), sim_fpu_denorm_zero); |
| 2616 |
| 2617 check_cvt_if(sd, status, 0); |
| 2618 |
| 2619 sim_fpu_to32 (&GR[reg3], &wop); |
| 2620 TRACE_FP_RESULT_FPU1 (&wop); |
| 2621 } |
| 2622 |
| 2623 // DIVF.D |
| 2624 rrrr,0111111,RRRR,0 + wwww,010001111110:F_I:::divf_d |
| 2625 *v850e2v3 |
| 2626 "divf.d r<reg1e>, r<reg2e>, r<reg3e>" |
| 2627 { |
| 2628 sim_fpu ans, wop1, wop2; |
| 2629 sim_fpu_status status; |
| 2630 |
| 2631 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2632 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2633 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2634 |
| 2635 status = sim_fpu_div (&ans, &wop2, &wop1); |
| 2636 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2637 |
| 2638 update_fpsr (sd, status, FPSR_XEV | FPSR_XEZ | FPSR_XEI | FPSR_XEO | FPSR_XEU,
1); |
| 2639 |
| 2640 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2641 TRACE_FP_RESULT_FPU1 (&ans); |
| 2642 } |
| 2643 |
| 2644 // DIVF.S |
| 2645 rrrrr,111111,RRRRR + wwwww,10001101110:F_I:::divf_s |
| 2646 *v850e2v3 |
| 2647 "divf.s r<reg1>, r<reg2>, r<reg3>" |
| 2648 { |
| 2649 sim_fpu ans, wop1, wop2; |
| 2650 sim_fpu_status status; |
| 2651 |
| 2652 sim_fpu_32to (&wop1, GR[reg1]); |
| 2653 sim_fpu_32to (&wop2, GR[reg2]); |
| 2654 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2655 |
| 2656 status = sim_fpu_div (&ans, &wop2, &wop1); |
| 2657 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2658 |
| 2659 update_fpsr (sd, status, FPSR_XEV | FPSR_XEZ | FPSR_XEI | FPSR_XEO | FPSR_XEU,
0); |
| 2660 |
| 2661 sim_fpu_to32 (&GR[reg3], &ans); |
| 2662 TRACE_FP_RESULT_FPU1 (&ans); |
| 2663 } |
| 2664 |
| 2665 // MADDF.S |
| 2666 rrrrr,111111,RRRRR + wwwww,101,W,00,WWWW,0:F_I:::maddf_s |
| 2667 *v850e2v3 |
| 2668 "maddf.s r<reg1>, r<reg2>, r<reg3>, r<reg4>" |
| 2669 { |
| 2670 sim_fpu ans, wop1, wop2, wop3; |
| 2671 sim_fpu_status status; |
| 2672 |
| 2673 sim_fpu_32to (&wop1, GR[reg1]); |
| 2674 sim_fpu_32to (&wop2, GR[reg2]); |
| 2675 sim_fpu_32to (&wop3, GR[reg3]); |
| 2676 TRACE_FP_INPUT_FPU3 (&wop1, &wop2, &wop3); |
| 2677 |
| 2678 status = sim_fpu_mul (&ans, &wop1, &wop2); |
| 2679 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2680 wop1 = ans; |
| 2681 status |= sim_fpu_add (&ans, &wop1, &wop3); |
| 2682 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2683 |
| 2684 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 2685 |
| 2686 sim_fpu_to32 (&GR[reg4], &ans); |
| 2687 TRACE_FP_RESULT_FPU1 (&ans); |
| 2688 } |
| 2689 |
| 2690 // MAXF.D |
| 2691 rrrr,0111111,RRRR,0 + wwww,010001111000:F_I:::maxf_d |
| 2692 *v850e2v3 |
| 2693 "maxf.d r<reg1e>, r<reg2e>, r<reg3e>" |
| 2694 { |
| 2695 sim_fpu ans, wop1, wop2; |
| 2696 |
| 2697 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2698 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2699 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2700 |
| 2701 if (sim_fpu_is_nan(&wop1) || sim_fpu_is_nan(&wop2)) |
| 2702 { |
| 2703 if (FPSR & FPSR_XEV) |
| 2704 { |
| 2705 SignalExceptionFPE(sd, 1); |
| 2706 } |
| 2707 else |
| 2708 { |
| 2709 ans = sim_fpu_qnan; |
| 2710 } |
| 2711 } |
| 2712 else if (FPSR & FPSR_FS |
| 2713 && ((sim_fpu_is_zero (&wop1) || sim_fpu_is_denorm (&wop1)) |
| 2714 && (sim_fpu_is_zero (&wop2) || sim_fpu_is_denorm (&wop2)))) |
| 2715 { |
| 2716 ans = sim_fpu_zero; |
| 2717 } |
| 2718 else |
| 2719 { |
| 2720 sim_fpu_max (&ans, &wop1, &wop2); |
| 2721 } |
| 2722 |
| 2723 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2724 TRACE_FP_RESULT_FPU1 (&ans); |
| 2725 } |
| 2726 |
| 2727 // MAXF.S |
| 2728 rrrrr,111111,RRRRR + wwwww,10001101000:F_I:::maxf_s |
| 2729 *v850e2v3 |
| 2730 "maxf.s r<reg1>, r<reg2>, r<reg3>" |
| 2731 { |
| 2732 sim_fpu ans, wop1, wop2; |
| 2733 |
| 2734 sim_fpu_32to (&wop1, GR[reg1]); |
| 2735 sim_fpu_32to (&wop2, GR[reg2]); |
| 2736 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2737 |
| 2738 if (sim_fpu_is_nan(&wop1) || sim_fpu_is_nan(&wop2)) |
| 2739 { |
| 2740 if (FPSR & FPSR_XEV) |
| 2741 { |
| 2742 SignalExceptionFPE(sd, 0); |
| 2743 } |
| 2744 else |
| 2745 { |
| 2746 ans = sim_fpu_qnan; |
| 2747 } |
| 2748 } |
| 2749 else if ((FPSR & FPSR_FS) |
| 2750 && ((sim_fpu_is_zero (&wop1) || sim_fpu_is_denorm (&wop1)) |
| 2751 && (sim_fpu_is_zero (&wop2)|| sim_fpu_is_denorm (&wop2)))) |
| 2752 { |
| 2753 ans = sim_fpu_zero; |
| 2754 } |
| 2755 else |
| 2756 { |
| 2757 sim_fpu_max (&ans, &wop1, &wop2); |
| 2758 } |
| 2759 |
| 2760 sim_fpu_to32 (&GR[reg3], &ans); |
| 2761 TRACE_FP_RESULT_FPU1 (&ans); |
| 2762 } |
| 2763 |
| 2764 // MINF.D |
| 2765 rrrr,0111111,RRRR,0 + wwww,010001111010:F_I:::minf_d |
| 2766 *v850e2v3 |
| 2767 "minf.d r<reg1e>, r<reg2e>, r<reg3e>" |
| 2768 { |
| 2769 sim_fpu ans, wop1, wop2; |
| 2770 |
| 2771 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2772 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2773 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2774 |
| 2775 if (sim_fpu_is_nan(&wop1) || sim_fpu_is_nan(&wop2)) |
| 2776 { |
| 2777 if (FPSR & FPSR_XEV) |
| 2778 { |
| 2779 SignalExceptionFPE(sd, 1); |
| 2780 } |
| 2781 else |
| 2782 { |
| 2783 ans = sim_fpu_qnan; |
| 2784 } |
| 2785 } |
| 2786 else if (FPSR & FPSR_FS |
| 2787 && ((sim_fpu_is_zero (&wop1) || sim_fpu_is_denorm (&wop1)) |
| 2788 && (sim_fpu_is_zero (&wop2) || sim_fpu_is_denorm (&wop2)))) |
| 2789 { |
| 2790 ans = sim_fpu_zero; |
| 2791 } |
| 2792 else |
| 2793 { |
| 2794 sim_fpu_min (&ans, &wop1, &wop2); |
| 2795 } |
| 2796 |
| 2797 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2798 TRACE_FP_RESULT_FPU1 (&ans); |
| 2799 } |
| 2800 |
| 2801 // MINF.S |
| 2802 rrrrr,111111,RRRRR + wwwww,10001101010:F_I:::minf_s |
| 2803 *v850e2v3 |
| 2804 "minf.s r<reg1>, r<reg2>, r<reg3>" |
| 2805 { |
| 2806 sim_fpu ans, wop1, wop2; |
| 2807 |
| 2808 sim_fpu_32to (&wop1, GR[reg1]); |
| 2809 sim_fpu_32to (&wop2, GR[reg2]); |
| 2810 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2811 |
| 2812 if (sim_fpu_is_nan(&wop1) || sim_fpu_is_nan(&wop2)) |
| 2813 { |
| 2814 if (FPSR & FPSR_XEV) |
| 2815 { |
| 2816 SignalExceptionFPE(sd, 0); |
| 2817 } |
| 2818 else |
| 2819 { |
| 2820 ans = sim_fpu_qnan; |
| 2821 } |
| 2822 } |
| 2823 else if (FPSR & FPSR_FS |
| 2824 && ((sim_fpu_is_zero (&wop1) || sim_fpu_is_denorm (&wop1)) |
| 2825 && (sim_fpu_is_zero (&wop2) || sim_fpu_is_denorm (&wop2)))) |
| 2826 { |
| 2827 ans = sim_fpu_zero; |
| 2828 } |
| 2829 else |
| 2830 { |
| 2831 sim_fpu_min (&ans, &wop1, &wop2); |
| 2832 } |
| 2833 |
| 2834 sim_fpu_to32 (&GR[reg3], &ans); |
| 2835 TRACE_FP_RESULT_FPU1 (&ans); |
| 2836 } |
| 2837 |
| 2838 // MSUBF.S |
| 2839 rrrrr,111111,RRRRR + wwwww,101,W,01,WWWW,0:F_I:::msubf_s |
| 2840 *v850e2v3 |
| 2841 "msubf.s r<reg1>, r<reg2>, r<reg3>, r<reg4>" |
| 2842 { |
| 2843 sim_fpu ans, wop1, wop2, wop3; |
| 2844 sim_fpu_status status; |
| 2845 |
| 2846 sim_fpu_32to (&wop1, GR[reg1]); |
| 2847 sim_fpu_32to (&wop2, GR[reg2]); |
| 2848 sim_fpu_32to (&wop3, GR[reg3]); |
| 2849 TRACE_FP_INPUT_FPU3 (&wop1, &wop2, &wop3); |
| 2850 |
| 2851 status = sim_fpu_mul (&ans, &wop1, &wop2); |
| 2852 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2853 wop1 = ans; |
| 2854 status |= sim_fpu_sub (&ans, &wop1, &wop3); |
| 2855 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2856 |
| 2857 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 2858 |
| 2859 sim_fpu_to32 (&GR[reg4], &ans); |
| 2860 TRACE_FP_RESULT_FPU1 (&ans); |
| 2861 } |
| 2862 |
| 2863 // MULF.D |
| 2864 rrrr,0111111,RRRR,0 + wwww,010001110100:F_I:::mulf_d |
| 2865 *v850e2v3 |
| 2866 "mulf.d r<reg1e>, r<reg2e>, r<reg3e>" |
| 2867 { |
| 2868 sim_fpu ans, wop1, wop2; |
| 2869 sim_fpu_status status; |
| 2870 |
| 2871 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 2872 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 2873 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2874 |
| 2875 status = sim_fpu_mul (&ans, &wop1, &wop2); |
| 2876 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2877 |
| 2878 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 1); |
| 2879 |
| 2880 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2881 TRACE_FP_RESULT_FPU1 (&ans); |
| 2882 } |
| 2883 |
| 2884 // MULF.S |
| 2885 rrrrr,111111,RRRRR + wwwww,10001100100:F_I:::mulf_s |
| 2886 *v850e2v3 |
| 2887 "mulf.s r<reg1>, r<reg2>, r<reg3>" |
| 2888 { |
| 2889 sim_fpu ans, wop1, wop2; |
| 2890 sim_fpu_status status; |
| 2891 |
| 2892 sim_fpu_32to (&wop1, GR[reg1]); |
| 2893 sim_fpu_32to (&wop2, GR[reg2]); |
| 2894 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 2895 |
| 2896 status = sim_fpu_mul (&ans, &wop1, &wop2); |
| 2897 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2898 |
| 2899 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 2900 |
| 2901 sim_fpu_to32 (&GR[reg3], &ans); |
| 2902 TRACE_FP_RESULT_FPU1 (&ans); |
| 2903 } |
| 2904 |
| 2905 // NEGF.D |
| 2906 rrrr,011111100001 + wwww,010001011000:F_I:::negf_d |
| 2907 *v850e2v3 |
| 2908 "negf.d r<reg2e>, r<reg3e>" |
| 2909 { |
| 2910 sim_fpu ans, wop; |
| 2911 sim_fpu_status status; |
| 2912 |
| 2913 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 2914 TRACE_FP_INPUT_FPU1 (&wop); |
| 2915 |
| 2916 status = sim_fpu_neg (&ans, &wop); |
| 2917 |
| 2918 check_invalid_snan(sd, status, 1); |
| 2919 |
| 2920 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 2921 TRACE_FP_RESULT_FPU1 (&ans); |
| 2922 } |
| 2923 |
| 2924 // NEGF.S |
| 2925 rrrrr,11111100001 + wwwww,10001001000:F_I:::negf_s |
| 2926 *v850e2v3 |
| 2927 "negf.s r<reg2>, r<reg3>" |
| 2928 { |
| 2929 sim_fpu ans, wop; |
| 2930 sim_fpu_status status; |
| 2931 |
| 2932 sim_fpu_32to (&wop, GR[reg2]); |
| 2933 TRACE_FP_INPUT_FPU1 (&wop); |
| 2934 |
| 2935 status = sim_fpu_neg (&ans, &wop); |
| 2936 |
| 2937 check_invalid_snan(sd, status, 0); |
| 2938 |
| 2939 sim_fpu_to32 (&GR[reg3], &ans); |
| 2940 TRACE_FP_RESULT_FPU1 (&ans); |
| 2941 } |
| 2942 |
| 2943 // NMADDF.S |
| 2944 rrrrr,111111,RRRRR + wwwww,101,W,10,WWWW,0:F_I:::nmaddf_s |
| 2945 *v850e2v3 |
| 2946 "nmaddf.s r<reg1>, r<reg2>, r<reg3>, r<reg4>" |
| 2947 { |
| 2948 sim_fpu ans, wop1, wop2, wop3; |
| 2949 sim_fpu_status status; |
| 2950 |
| 2951 sim_fpu_32to (&wop1, GR[reg1]); |
| 2952 sim_fpu_32to (&wop2, GR[reg2]); |
| 2953 sim_fpu_32to (&wop3, GR[reg3]); |
| 2954 TRACE_FP_INPUT_FPU3 (&wop1, &wop2, &wop3); |
| 2955 |
| 2956 status = sim_fpu_mul (&ans, &wop1, &wop2); |
| 2957 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2958 wop1 = ans; |
| 2959 status |= sim_fpu_add (&ans, &wop1, &wop3); |
| 2960 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2961 wop1 = ans; |
| 2962 status |= sim_fpu_neg (&ans, &wop1); |
| 2963 |
| 2964 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 2965 |
| 2966 sim_fpu_to32 (&GR[reg4], &ans); |
| 2967 TRACE_FP_RESULT_FPU1 (&ans); |
| 2968 } |
| 2969 |
| 2970 // NMSUBF.S |
| 2971 rrrrr,111111,RRRRR + wwwww,101,W,11,WWWW,0:F_I:::nmsubf_s |
| 2972 *v850e2v3 |
| 2973 "nmsubf.s r<reg1>, r<reg2>, r<reg3>, r<reg4>" |
| 2974 { |
| 2975 sim_fpu ans, wop1, wop2, wop3; |
| 2976 sim_fpu_status status; |
| 2977 |
| 2978 sim_fpu_32to (&wop1, GR[reg1]); |
| 2979 sim_fpu_32to (&wop2, GR[reg2]); |
| 2980 sim_fpu_32to (&wop3, GR[reg3]); |
| 2981 TRACE_FP_INPUT_FPU3 (&wop1, &wop2, &wop3); |
| 2982 |
| 2983 status = sim_fpu_mul (&ans, &wop1, &wop2); |
| 2984 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2985 wop1 = ans; |
| 2986 status |= sim_fpu_sub (&ans, &wop1, &wop3); |
| 2987 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 2988 wop1 = ans; |
| 2989 status |= sim_fpu_neg (&ans, &wop1); |
| 2990 |
| 2991 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 2992 |
| 2993 sim_fpu_to32 (&GR[reg4], &ans); |
| 2994 TRACE_FP_RESULT_FPU1 (&ans); |
| 2995 } |
| 2996 |
| 2997 // RECIPF.D |
| 2998 rrrr,011111100001 + wwww,010001011110:F_I:::recipf.d |
| 2999 *v850e2v3 |
| 3000 "recipf.d r<reg2e>, r<reg3e>" |
| 3001 { |
| 3002 sim_fpu ans, wop; |
| 3003 sim_fpu_status status; |
| 3004 |
| 3005 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 3006 TRACE_FP_INPUT_FPU1 (&wop); |
| 3007 |
| 3008 status = sim_fpu_div (&ans, &sim_fpu_one, &wop); |
| 3009 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3010 |
| 3011 update_fpsr (sd, status, FPSR_XEV | FPSR_XEZ | FPSR_XEI | FPSR_XEO | FPSR_XEU,
1); |
| 3012 |
| 3013 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 3014 TRACE_FP_RESULT_FPU1 (&ans); |
| 3015 } |
| 3016 |
| 3017 // RECIPF.S |
| 3018 rrrrr,11111100001 + wwwww,10001001110:F_I:::recipf.s |
| 3019 *v850e2v3 |
| 3020 "recipf.s r<reg2>, r<reg3>" |
| 3021 { |
| 3022 sim_fpu ans, wop; |
| 3023 sim_fpu_status status; |
| 3024 |
| 3025 sim_fpu_32to (&wop, GR[reg2]); |
| 3026 TRACE_FP_INPUT_FPU1 (&wop); |
| 3027 |
| 3028 status = sim_fpu_div (&ans, &sim_fpu_one, &wop); |
| 3029 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3030 |
| 3031 update_fpsr (sd, status, FPSR_XEV | FPSR_XEZ | FPSR_XEI | FPSR_XEO | FPSR_XEU,
0); |
| 3032 |
| 3033 sim_fpu_to32 (&GR[reg3], &ans); |
| 3034 TRACE_FP_RESULT_FPU1 (&ans); |
| 3035 } |
| 3036 |
| 3037 // RSQRTF.D |
| 3038 rrrr,011111100010 + wwww,010001011110:F_I:::rsqrtf.d |
| 3039 *v850e2v3 |
| 3040 "rsqrtf.d r<reg2e>, r<reg3e>" |
| 3041 { |
| 3042 sim_fpu ans, wop; |
| 3043 sim_fpu_status status; |
| 3044 |
| 3045 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 3046 TRACE_FP_INPUT_FPU1 (&wop); |
| 3047 |
| 3048 status = sim_fpu_sqrt (&ans, &wop); |
| 3049 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3050 wop = ans; |
| 3051 status = sim_fpu_div (&ans, &sim_fpu_one, &wop); |
| 3052 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3053 |
| 3054 update_fpsr (sd, status, FPSR_XEV | FPSR_XEZ | FPSR_XEI | FPSR_XEO | FPSR_XEU,
1); |
| 3055 |
| 3056 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 3057 TRACE_FP_RESULT_FPU1 (&ans); |
| 3058 } |
| 3059 |
| 3060 // RSQRTF.S |
| 3061 rrrrr,11111100010 + wwwww,10001001110:F_I:::rsqrtf.s |
| 3062 *v850e2v3 |
| 3063 "rsqrtf.s r<reg2>, r<reg3>" |
| 3064 { |
| 3065 sim_fpu ans, wop; |
| 3066 sim_fpu_status status; |
| 3067 |
| 3068 sim_fpu_32to (&wop, GR[reg2]); |
| 3069 TRACE_FP_INPUT_FPU1 (&wop); |
| 3070 |
| 3071 status = sim_fpu_sqrt (&ans, &wop); |
| 3072 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3073 wop = ans; |
| 3074 status = sim_fpu_div (&ans, &sim_fpu_one, &wop); |
| 3075 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3076 |
| 3077 update_fpsr (sd, status, FPSR_XEV | FPSR_XEZ | FPSR_XEI | FPSR_XEO | FPSR_XEU,
0); |
| 3078 |
| 3079 sim_fpu_to32 (&GR[reg3], &ans); |
| 3080 TRACE_FP_RESULT_FPU1 (&ans); |
| 3081 } |
| 3082 |
| 3083 // SQRTF.D |
| 3084 rrrr,011111100000 + wwww,010001011110:F_I:::sqrtf.d |
| 3085 *v850e2v3 |
| 3086 "sqrtf.d r<reg2e>, r<reg3e>" |
| 3087 { |
| 3088 sim_fpu ans, wop; |
| 3089 sim_fpu_status status; |
| 3090 |
| 3091 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 3092 TRACE_FP_INPUT_FPU1 (&wop); |
| 3093 |
| 3094 status = sim_fpu_sqrt (&ans, &wop); |
| 3095 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3096 |
| 3097 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI, 1); |
| 3098 |
| 3099 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 3100 TRACE_FP_RESULT_FPU1 (&ans); |
| 3101 } |
| 3102 |
| 3103 // SQRTF.S |
| 3104 rrrrr,11111100000 + wwwww,10001001110:F_I:::sqrtf.s |
| 3105 *v850e2v3 |
| 3106 "sqrtf.s r<reg2>, r<reg3>" |
| 3107 { |
| 3108 sim_fpu ans, wop; |
| 3109 sim_fpu_status status; |
| 3110 |
| 3111 sim_fpu_32to (&wop, GR[reg2]); |
| 3112 TRACE_FP_INPUT_FPU1 (&wop); |
| 3113 |
| 3114 status = sim_fpu_sqrt (&ans, &wop); |
| 3115 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3116 |
| 3117 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI, 0); |
| 3118 |
| 3119 sim_fpu_to32 (&GR[reg3], &ans); |
| 3120 TRACE_FP_RESULT_FPU1 (&ans); |
| 3121 } |
| 3122 |
| 3123 // SUBF.D |
| 3124 rrrr,0111111,RRRR,0 + wwww,010001110010:F_I:::subf.d |
| 3125 *v850e2v3 |
| 3126 "subf.d r<reg1e>, r<reg2e>, r<reg3e>" |
| 3127 { |
| 3128 sim_fpu ans, wop1, wop2; |
| 3129 sim_fpu_status status; |
| 3130 |
| 3131 sim_fpu_232to (&wop1, GR[reg1e+1], GR[reg1e]); |
| 3132 sim_fpu_232to (&wop2, GR[reg2e+1], GR[reg2e]); |
| 3133 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 3134 |
| 3135 status = sim_fpu_sub (&ans, &wop2, &wop1); |
| 3136 status |= sim_fpu_round_64 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3137 |
| 3138 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 1); |
| 3139 |
| 3140 sim_fpu_to232 (&GR[reg3e+1], &GR[reg3e], &ans); |
| 3141 TRACE_FP_RESULT_FPU1 (&ans); |
| 3142 } |
| 3143 |
| 3144 // SUBF.S |
| 3145 rrrrr,111111,RRRRR + wwwww,10001100010:F_I:::subf.s |
| 3146 *v850e2v3 |
| 3147 "subf.s r<reg1>, r<reg2>, r<reg3>" |
| 3148 { |
| 3149 sim_fpu ans, wop1, wop2; |
| 3150 sim_fpu_status status; |
| 3151 |
| 3152 sim_fpu_32to (&wop1, GR[reg1]); |
| 3153 sim_fpu_32to (&wop2, GR[reg2]); |
| 3154 TRACE_FP_INPUT_FPU2 (&wop1, &wop2); |
| 3155 |
| 3156 status = sim_fpu_sub (&ans, &wop2, &wop1); |
| 3157 status |= sim_fpu_round_32 (&ans, FPSR_GET_ROUND(), sim_fpu_denorm_underflow_i
nexact); |
| 3158 |
| 3159 update_fpsr (sd, status, FPSR_XEV | FPSR_XEI | FPSR_XEO | FPSR_XEU, 0); |
| 3160 |
| 3161 sim_fpu_to32 (&GR[reg3], &ans); |
| 3162 TRACE_FP_RESULT_FPU1 (&ans); |
| 3163 } |
| 3164 |
| 3165 // TRFSR |
| 3166 0000011111100000 + 000001000000,bbb,0:F_I:::trfsr |
| 3167 *v850e2v3 |
| 3168 "trfsr":(bbb == 0) |
| 3169 "trfsr <bbb>" |
| 3170 { |
| 3171 TRACE_ALU_INPUT1 (GET_FPCC()); |
| 3172 |
| 3173 if (TEST_FPCC (bbb)) |
| 3174 PSW |= PSW_Z; |
| 3175 else |
| 3176 PSW &= ~PSW_Z; |
| 3177 |
| 3178 TRACE_ALU_RESULT1 (PSW); |
| 3179 } |
| 3180 |
| 3181 // TRNCF.DL |
| 3182 rrrr,011111100001 + wwww,010001010100:F_I:::trncf_dl |
| 3183 *v850e2v3 |
| 3184 "trncf.dl r<reg2e>, r<reg3e>" |
| 3185 { |
| 3186 signed64 ans; |
| 3187 sim_fpu wop; |
| 3188 sim_fpu_status status; |
| 3189 |
| 3190 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 3191 TRACE_FP_INPUT_FPU1 (&wop); |
| 3192 |
| 3193 status = sim_fpu_round_64 (&wop, sim_fpu_round_zero, sim_fpu_denorm_zero); |
| 3194 status |= sim_fpu_to64i (&ans, &wop, sim_fpu_round_zero); |
| 3195 |
| 3196 check_cvt_fi(sd, status, 1); |
| 3197 |
| 3198 GR[reg3e] = ans; |
| 3199 GR[reg3e+1] = ans>>32L; |
| 3200 TRACE_FP_RESULT_WORD2 (GR[reg3e], GR[reg3e+1]); |
| 3201 } |
| 3202 |
| 3203 // TRNCF.DW |
| 3204 rrrr,011111100001 + wwwww,10001010000:F_I:::trncf_dw |
| 3205 *v850e2v3 |
| 3206 "trncf.dw r<reg2e>, r<reg3>" |
| 3207 { |
| 3208 uint32 ans; |
| 3209 sim_fpu wop; |
| 3210 sim_fpu_status status; |
| 3211 |
| 3212 sim_fpu_232to (&wop, GR[reg2e+1], GR[reg2e]); |
| 3213 TRACE_FP_INPUT_FPU1 (&wop); |
| 3214 |
| 3215 status = sim_fpu_round_32 (&wop, sim_fpu_round_zero, sim_fpu_denorm_zero); |
| 3216 status |= sim_fpu_to32i (&ans, &wop, sim_fpu_round_zero); |
| 3217 |
| 3218 check_cvt_fi(sd, status, 1); |
| 3219 |
| 3220 GR[reg3] = ans; |
| 3221 TRACE_FP_RESULT_WORD1 (ans); |
| 3222 } |
| 3223 |
| 3224 // TRNCF.SL |
| 3225 rrrrr,11111100001 + wwww,010001000100:F_I:::trncf_sl |
| 3226 *v850e2v3 |
| 3227 "trncf.sl r<reg2>, r<reg3e>" |
| 3228 { |
| 3229 signed64 ans; |
| 3230 sim_fpu wop; |
| 3231 sim_fpu_status status; |
| 3232 |
| 3233 sim_fpu_32to (&wop, GR[reg2]); |
| 3234 TRACE_FP_INPUT_FPU1 (&wop); |
| 3235 |
| 3236 status = sim_fpu_round_64 (&wop, sim_fpu_round_zero, sim_fpu_denorm_zero); |
| 3237 status |= sim_fpu_to64i (&ans, &wop, sim_fpu_round_zero); |
| 3238 |
| 3239 GR[reg3e] = ans; |
| 3240 GR[reg3e+1] = ans >> 32L; |
| 3241 TRACE_FP_RESULT_WORD2 (GR[reg3e], GR[reg3e+1]); |
| 3242 } |
| 3243 |
| 3244 // TRNCF.SW |
| 3245 rrrrr,11111100001 + wwwww,10001000000:F_I:::trncf_sw |
| 3246 *v850e2v3 |
| 3247 "trncf.sw r<reg2>, r<reg3>" |
| 3248 { |
| 3249 uint32 ans; |
| 3250 sim_fpu wop; |
| 3251 sim_fpu_status status; |
| 3252 |
| 3253 sim_fpu_32to (&wop, GR[reg2]); |
| 3254 TRACE_FP_INPUT_FPU1 (&wop); |
| 3255 |
| 3256 status = sim_fpu_round_32 (&wop, sim_fpu_round_zero, sim_fpu_denorm_zero); |
| 3257 status |= sim_fpu_to32i (&ans, &wop, sim_fpu_round_zero); |
| 3258 |
| 3259 check_cvt_fi(sd, status, 0); |
| 3260 |
| 3261 GR[reg3] = ans; |
| 3262 TRACE_FP_RESULT_WORD1 (ans); |
| 3263 } |
| 3264 |
OLD | NEW |