ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/uae_cpu/m68k.h
(Generate patch)

Comparing BasiliskII/src/uae_cpu/m68k.h (file contents):
Revision 1.1 by cebix, 1999-10-03T14:16:26Z vs.
Revision 1.2 by cebix, 1999-10-21T15:27:11Z

# Line 6 | Line 6
6    * Copyright 1996 Bernd Schmidt
7    */
8  
9 < #ifdef __i386__
9 > #if defined(__i386__) && defined(X86_ASSEMBLY)
10  
11   struct flag_struct {
12      unsigned int cznv;
# Line 142 | Line 142 | static __inline__ int cctrue(int cc)
142                          "popl %0\n\t" \
143                          : "=r" (regflags.cznv) : "qmi" (s), "q" (d) : "cc")
144  
145 + #elif defined(__sparc__) && (defined(SPARC_V8_ASSEMBLY) || defined(SPARC_V9_ASSEMBLY))
146 +
147 + struct flag_struct {
148 +    unsigned char nzvc;
149 +    unsigned char x;
150 + };
151 +
152 + extern struct flag_struct regflags;
153 +
154 + #define SET_ZFLG(y) (regflags.nzvc = (regflags.nzvc & ~0x04) | (((y) & 1) << 2))
155 + #define SET_CFLG(y) (regflags.nzvc = (regflags.nzvc & ~1) | ((y) & 1))
156 + #define SET_VFLG(y) (regflags.nzvc = (regflags.nzvc & ~0x02) | (((y) & 1) << 1))
157 + #define SET_NFLG(y) (regflags.nzvc = (regflags.nzvc & ~0x08) | (((y) & 1) << 3))
158 + #define SET_XFLG(y) (regflags.x = (y))
159 +
160 + #define GET_ZFLG ((regflags.nzvc >> 2) & 1)
161 + #define GET_CFLG (regflags.nzvc & 1)
162 + #define GET_VFLG ((regflags.nzvc >> 1) & 1)
163 + #define GET_NFLG ((regflags.nzvc >> 3) & 1)
164 + #define GET_XFLG (regflags.x & 1)
165 +
166 + #define CLEAR_CZNV (regflags.nzvc = 0)
167 + #define COPY_CARRY (regflags.x = regflags.nzvc)
168 +
169 + static __inline__ int cctrue(int cc)
170 + {
171 +    uae_u32 nzvc = regflags.nzvc;
172 +    switch(cc){
173 +     case 0: return 1;                       /* T */
174 +     case 1: return 0;                       /* F */
175 +     case 2: return (nzvc & 0x05) == 0; /* !GET_CFLG && !GET_ZFLG;  HI */
176 +     case 3: return (nzvc & 0x05) != 0; /* GET_CFLG || GET_ZFLG;    LS */
177 +     case 4: return (nzvc & 1) == 0;        /* !GET_CFLG;               CC */
178 +     case 5: return (nzvc & 1) != 0;           /* GET_CFLG;                CS */
179 +     case 6: return (nzvc & 0x04) == 0; /* !GET_ZFLG;               NE */
180 +     case 7: return (nzvc & 0x04) != 0; /* GET_ZFLG;                EQ */
181 +     case 8: return (nzvc & 0x02) == 0;/* !GET_VFLG;               VC */
182 +     case 9: return (nzvc & 0x02) != 0;/* GET_VFLG;                VS */
183 +     case 10:return (nzvc & 0x08) == 0; /* !GET_NFLG;               PL */
184 +     case 11:return (nzvc & 0x08) != 0; /* GET_NFLG;                MI */
185 +     case 12:return (((nzvc << 2) ^ nzvc) & 0x08) == 0; /* GET_NFLG == GET_VFLG;             GE */
186 +     case 13:return (((nzvc << 2) ^ nzvc) & 0x08) != 0;/* GET_NFLG != GET_VFLG;             LT */
187 +     case 14:
188 +        nzvc &= 0x0e;
189 +        return (((nzvc << 2) ^ nzvc) & 0x0c) == 0; /* !GET_ZFLG && (GET_NFLG == GET_VFLG);  GT */
190 +     case 15:
191 +        nzvc &= 0x0e;
192 +        return (((nzvc << 2) ^ nzvc) & 0x0c) != 0; /* GET_ZFLG || (GET_NFLG != GET_VFLG);   LE */
193 +    }
194 +    return 0;
195 + }
196 +
197 + #ifdef SPARC_V8_ASSEMBLY
198 +
199 + static inline uae_u32 sparc_v8_flag_add_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
200 + {
201 +        uae_u32 value;
202 +        __asm__ ("\n"
203 +                "       sll             %2, 24, %%o0\n"
204 +                "       sll             %3, 24, %%o1\n"
205 +                "       addcc   %%o0, %%o1, %%o0\n"
206 +                "       addx    %%g0, %%g0, %%o1        ! X,C flags\n"
207 +                "       srl             %%o0, 24, %0\n"
208 +                "       stb             %%o1, [%1 + 1]\n"
209 +                "       bl,a    .+8\n"
210 +                "       or              %%o1, 0x08, %%o1        ! N flag\n"
211 +                "       bz,a    .+8\n"
212 +                "       or              %%o1, 0x04, %%o1        ! Z flag\n"
213 +                "       bvs,a   .+8\n"
214 +                "       or              %%o1, 0x02, %%o1        ! V flag\n"
215 +                "       stb             %%o1, [%1]\n"
216 +        :       "=&r" (value)
217 +        :       "r" (flags), "r" (dst), "r" (src)
218 +        :       "cc", "o0", "o1"
219 +        );
220 +        return value;
221 + }
222 +
223 + static inline uae_u32 sparc_v8_flag_add_16(flag_struct *flags, uae_u32 src, uae_u32 dst)
224 + {
225 +        uae_u32 value;
226 +        __asm__ ("\n"
227 +                "       sll             %2, 16, %%o0\n"
228 +                "       sll             %3, 16, %%o1\n"
229 +                "       addcc   %%o0, %%o1, %%o0\n"
230 +                "       addx    %%g0, %%g0, %%o1        ! X,C flags\n"
231 +                "       srl             %%o0, 16, %0\n"
232 +                "       stb             %%o1, [%1 + 1]\n"
233 +                "       bl,a    .+8\n"
234 +                "       or              %%o1, 0x08, %%o1        ! N flag\n"
235 +                "       bz,a    .+8\n"
236 +                "       or              %%o1, 0x04, %%o1        ! Z flag\n"
237 +                "       bvs,a   .+8\n"
238 +                "       or              %%o1, 0x02, %%o1        ! V flag\n"
239 +                "       stb             %%o1, [%1]\n"
240 +        :       "=&r" (value)
241 +        :       "r" (flags), "r" (dst), "r" (src)
242 +        :       "cc", "o0", "o1"
243 +        );
244 +        return value;
245 + }
246 +
247 + static inline uae_u32 sparc_v8_flag_add_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
248 + {
249 +        uae_u32 value;
250 +        __asm__ ("\n"
251 +                "       addcc   %2, %3, %0\n"
252 +                "       addx    %%g0, %%g0, %%o0        ! X,C flags\n"
253 +                "       stb             %%o0, [%1 + 1]\n"
254 +                "       bl,a    .+8\n"
255 +                "       or              %%o0, 0x08, %%o0        ! N flag\n"
256 +                "       bz,a    .+8\n"
257 +                "       or              %%o0, 0x04, %%o0        ! Z flag\n"
258 +                "       bvs,a   .+8\n"
259 +                "       or              %%o0, 0x02, %%o0        ! V flag\n"
260 +                "       stb             %%o0, [%1]\n"
261 +        :       "=&r" (value)
262 +        :       "r" (flags), "r" (dst), "r" (src)
263 +        :       "cc", "o0"
264 +        );
265 +        return value;
266 + }
267 +
268 + static inline uae_u32 sparc_v8_flag_sub_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
269 + {
270 +        uae_u32 value;
271 +        __asm__ ("\n"
272 +                "       sll             %2, 24, %%o0\n"
273 +                "       sll             %3, 24, %%o1\n"
274 +                "       subcc   %%o0, %%o1, %%o0\n"
275 +                "       addx    %%g0, %%g0, %%o1        ! X,C flags\n"
276 +                "       srl             %%o0, 24, %0\n"
277 +                "       stb             %%o1, [%1 + 1]\n"
278 +                "       bl,a    .+8\n"
279 +                "       or              %%o1, 0x08, %%o1        ! N flag\n"
280 +                "       bz,a    .+8\n"
281 +                "       or              %%o1, 0x04, %%o1        ! Z flag\n"
282 +                "       bvs,a   .+8\n"
283 +                "       or              %%o1, 0x02, %%o1        ! V flag\n"
284 +                "       stb             %%o1, [%1]\n"
285 +        :       "=&r" (value)
286 +        :       "r" (flags), "r" (dst), "r" (src)
287 +        :       "cc", "o0", "o1"
288 +        );
289 +        return value;
290 + }
291 +
292 + static inline uae_u32 sparc_v8_flag_sub_16(flag_struct *flags, uae_u32 src, uae_u32 dst)
293 + {
294 +        uae_u32 value;
295 +        __asm__ ("\n"
296 +                "       sll             %2, 16, %%o0\n"
297 +                "       sll             %3, 16, %%o1\n"
298 +                "       subcc   %%o0, %%o1, %%o0\n"
299 +                "       addx    %%g0, %%g0, %%o1        ! X,C flags\n"
300 +                "       srl             %%o0, 16, %0\n"
301 +                "       stb             %%o1, [%1 + 1]\n"
302 +                "       bl,a    .+8\n"
303 +                "       or              %%o1, 0x08, %%o1        ! N flag\n"
304 +                "       bz,a    .+8\n"
305 +                "       or              %%o1, 0x04, %%o1        ! Z flag\n"
306 +                "       bvs,a   .+8\n"
307 +                "       or              %%o1, 0x02, %%o1        ! V flag\n"
308 +                "       stb             %%o1, [%1]\n"
309 +        :       "=&r" (value)
310 +        :       "r" (flags), "r" (dst), "r" (src)
311 +        :       "cc", "o0", "o1"
312 +        );
313 +        return value;
314 + }
315 +
316 + static inline uae_u32 sparc_v8_flag_sub_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
317 + {
318 +        uae_u32 value;
319 +        __asm__ ("\n"
320 +                "       subcc   %2, %3, %0\n"
321 +                "       addx    %%g0, %%g0, %%o0        ! X,C flags\n"
322 +                "       stb             %%o0, [%1 + 1]\n"
323 +                "       bl,a    .+8\n"
324 +                "       or              %%o0, 0x08, %%o0        ! N flag\n"
325 +                "       bz,a    .+8\n"
326 +                "       or              %%o0, 0x04, %%o0        ! Z flag\n"
327 +                "       bvs,a   .+8\n"
328 +                "       or              %%o0, 0x02, %%o0        ! V flag\n"
329 +                "       stb             %%o0, [%1]\n"
330 +        :       "=&r" (value)
331 +        :       "r" (flags), "r" (dst), "r" (src)
332 +        :       "cc", "o0"
333 +        );
334 +        return value;
335 + }
336 +
337 + static inline void sparc_v8_flag_cmp_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
338 + {
339 +        __asm__ ("\n"
340 +                "       sll             %1, 24, %%o0\n"
341 +                "       sll             %2, 24, %%o1\n"
342 +                "       subcc   %%o0, %%o1, %%g0\n"
343 +                "       addx    %%g0, %%g0, %%o0        ! C flag\n"
344 +                "       bl,a    .+8\n"
345 +                "       or              %%o0, 0x08, %%o0        ! N flag\n"
346 +                "       bz,a    .+8\n"
347 +                "       or              %%o0, 0x04, %%o0        ! Z flag\n"
348 +                "       bvs,a   .+8\n"
349 +                "       or              %%o0, 0x02, %%o0        ! V flag\n"
350 +                "       stb             %%o0, [%0]\n"
351 +        :       /* no outputs */
352 +        :       "r" (flags), "r" (dst), "r" (src)
353 +        :       "cc", "o0", "o1"
354 +        );
355 + }
356 +
357 + static inline void sparc_v8_flag_cmp_16(flag_struct *flags, uae_u32 src, uae_u32 dst)
358 + {
359 +        __asm__ ("\n"
360 +                "       sll             %1, 16, %%o0\n"
361 +                "       sll             %2, 16, %%o1\n"
362 +                "       subcc   %%o0, %%o1, %%g0\n"
363 +                "       addx    %%g0, %%g0, %%o0        ! C flag\n"
364 +                "       bl,a    .+8\n"
365 +                "       or              %%o0, 0x08, %%o0        ! N flag\n"
366 +                "       bz,a    .+8\n"
367 +                "       or              %%o0, 0x04, %%o0        ! Z flag\n"
368 +                "       bvs,a   .+8\n"
369 +                "       or              %%o0, 0x02, %%o0        ! V flag\n"
370 +                "       stb             %%o0, [%0]\n"
371 +        :       /* no outputs */
372 +        :       "r" (flags), "r" (dst), "r" (src)
373 +        :       "cc", "o0", "o1"
374 +        );
375 + }
376 +
377 + static inline void sparc_v8_flag_cmp_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
378 + {
379 +        __asm__ ("\n"
380 +                "       subcc   %1, %2, %%o1\n"
381 +                "       srl             %%o1, 31, %%o0\n"
382 +                "       sll             %%o0, 3, %%o0\n"
383 +                "       addx    %%o0, %%g0, %%o0\n"
384 +                "       bvs,a   .+8\n"
385 +                "       or              %%o0, 0x02, %%o0\n"
386 +                "       subcc   %%g0, %%o1, %%g0\n"
387 +                "       addx    %%g0, 7, %%o1\n"
388 +                "       and             %%o1, 0x04, %%o1\n"
389 +                "       or              %%o0, %%o1, %%o0\n"
390 +                "       stb             %%o0, [%0]\n"
391 +        :       /* no outputs */
392 +        :       "r" (flags), "r" (dst), "r" (src)
393 +        :       "cc", "o0", "o1"
394 +        );
395 + }
396 +
397 + static inline uae_u32 sparc_v8_flag_addx_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
398 + {
399 +        uae_u32 value;
400 +        __asm__ ("\n"
401 +                "       ldub    [%1 + 1], %%o1          ! Get the X Flag\n"
402 +                "       subcc   %%g0, %%o1, %%g0        ! Set the SPARC carry flag, if X set\n"
403 +                "       addxcc  %2, %3, %0\n"
404 +        :       "=&r" (value)
405 +        :       "r" (flags), "r" (dst), "r" (src)
406 +        :       "cc", "o0", "o1"
407 +        );
408 +        return value;
409 + }
410 +
411 + #if 0
412 + VERY SLOW...
413 + static inline uae_u32 sparc_v8_flag_addx_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
414 + {
415 +        uae_u32 value;
416 +        __asm__ ("\n"
417 +                "       sll             %2, 24, %%o0\n"
418 +                "       sll             %3, 24, %%o1\n"
419 +                "       addcc   %%o0, %%o1, %%o0\n"
420 +                "       addx    %%g0, %%g0, %%o1        ! X,C flags\n"
421 +                "       bvs,a   .+8\n"
422 +                "       or              %%o1, 0x02, %%o1        ! V flag\n"
423 +                "       ldub    [%1 + 1], %%o2\n"
424 +                "       subcc   %%g0, %%o2, %%g0\n"
425 +                "       addx    %%g0, %%g0, %%o2\n"
426 +                "       sll             %%o2, 24, %%o2\n"
427 +                "       addcc   %%o0, %%o2, %%o0\n"
428 +                "       srl             %%o0, 24, %0\n"
429 +                "       addx    %%g0, %%g0, %%o2\n"
430 +                "       or              %%o1, %%o2, %%o1        ! update X,C flags\n"
431 +                "       bl,a    .+8\n"
432 +                "       or              %%o1, 0x08, %%o1        ! N flag\n"
433 +                "       ldub    [%1], %%o0                      ! retreive the old NZVC flags (XXX)\n"
434 +                "       bvs,a   .+8\n"
435 +                "       or              %%o1, 0x02, %%o1        ! update V flag\n"
436 +                "       and             %%o0, 0x04, %%o0        ! (XXX) but keep only Z flag\n"
437 +                "       and             %%o1, 1, %%o2           ! keep C flag in %%o2\n"
438 +                "       bnz,a   .+8\n"
439 +                "       or              %%g0, %%g0, %%o0        ! Z flag cleared if non-zero result\n"
440 +                "       stb             %%o2, [%1 + 1]          ! store the X flag\n"
441 +                "       or              %%o1, %%o0, %%o1\n"
442 +                "       stb             %%o1, [%1]\n"
443 +        :       "=&r" (value)
444 +        :       "r" (flags), "r" (dst), "r" (src)
445 +        :       "cc", "o0", "o1", "o2"
446 +        );
447 +        return value;
448 + }
449 + #endif
450 +
451 + static inline uae_u32 sparc_v8_flag_addx_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
452 + {
453 +        uae_u32 value;
454 +        __asm__ ("\n"
455 +                "       ldub    [%1 + 1], %%o0          ! Get the X Flag\n"
456 +                "       subcc   %%g0, %%o0, %%g0        ! Set the SPARC carry flag, if X set\n"
457 +                "       addxcc  %2, %3, %0\n"
458 +                "       ldub    [%1], %%o0                      ! retreive the old NZVC flags\n"
459 +                "       and             %%o0, 0x04, %%o0        ! but keep only Z flag\n"
460 +                "       addx    %%o0, %%g0, %%o0        ! X,C flags\n"
461 +                "       bl,a    .+8\n"
462 +                "       or              %%o0, 0x08, %%o0        ! N flag\n"
463 +                "       bvs,a   .+8\n"
464 +                "       or              %%o0, 0x02, %%o0        ! V flag\n"
465 +                "       bnz,a   .+8\n"
466 +                "       and             %%o0, 0x0B, %%o0        ! Z flag cleared if result is non-zero\n"
467 +                "       stb             %%o0, [%1]\n"
468 +                "       stb             %%o0, [%1 + 1]\n"
469 +        :       "=&r" (value)
470 +        :       "r" (flags), "r" (dst), "r" (src)
471 +        :       "cc", "o0"
472 +        );
473 +        return value;
474 + }
475 +
476 + #endif /* SPARC_V8_ASSEMBLY */
477 +
478 + #ifdef SPARC_V9_ASSEMBLY
479 +
480 + static inline uae_u32 sparc_v9_flag_add_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
481 + {
482 +        uae_u32 value;
483 +        __asm__ ("\n"
484 +                "       sll             %2, 24, %%o0\n"
485 +                "       sll             %3, 24, %%o1\n"
486 +                "       addcc   %%o0, %%o1, %%o0\n"
487 +                "       rd              %%ccr, %%o1\n"
488 +                "       srl             %%o0, 24, %0\n"
489 +                "       stb             %%o1, [%1]\n"
490 +                "       stb             %%o1, [%1+1]\n"
491 +        :       "=&r" (value)
492 +        :       "r" (flags), "r" (dst), "r" (src)
493 +        :       "cc", "o0", "o1"
494 +        );
495 +        return value;
496 + }
497 +
498 + static inline uae_u32 sparc_v9_flag_add_16(flag_struct *flags, uae_u32 src, uae_u32 dst)
499 + {
500 +        uae_u32 value;
501 +        __asm__ ("\n"
502 +                "       sll             %2, 16, %%o0\n"
503 +                "       sll             %3, 16, %%o1\n"
504 +                "       addcc   %%o0, %%o1, %%o0\n"
505 +                "       rd              %%ccr, %%o1\n"
506 +                "       srl             %%o0, 16, %0\n"
507 +                "       stb             %%o1, [%1]\n"
508 +                "       stb             %%o1, [%1+1]\n"
509 +        :       "=&r" (value)
510 +        :       "r" (flags), "r" (dst), "r" (src)
511 +        :       "cc", "o0", "o1"
512 +        );
513 +        return value;
514 + }
515 +
516 + static inline uae_u32 sparc_v9_flag_add_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
517 + {
518 +        uae_u32 value;
519 +        __asm__ ("\n"
520 +                "       addcc   %2, %3, %0\n"
521 +                "       rd              %%ccr, %%o0\n"
522 +                "       stb             %%o0, [%1]\n"
523 +                "       stb             %%o0, [%1+1]\n"
524 +        :       "=&r" (value)
525 +        :       "r" (flags), "r" (dst), "r" (src)
526 +        :       "cc", "o0"
527 +        );
528 +        return value;
529 + }
530 +
531 + static inline uae_u32 sparc_v9_flag_sub_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
532 + {
533 +        uae_u32 value;
534 +        __asm__ ("\n"
535 +                "       sll             %2, 24, %%o0\n"
536 +                "       sll             %3, 24, %%o1\n"
537 +                "       subcc   %%o0, %%o1, %%o0\n"
538 +                "       rd              %%ccr, %%o1\n"
539 +                "       srl             %%o0, 24, %0\n"
540 +                "       stb             %%o1, [%1]\n"
541 +                "       stb             %%o1, [%1+1]\n"
542 +        :       "=&r" (value)
543 +        :       "r" (flags), "r" (dst), "r" (src)
544 +        :       "cc", "o0", "o1"
545 +        );
546 +        return value;
547 + }
548 +
549 + static inline uae_u32 sparc_v9_flag_sub_16(flag_struct *flags, uae_u32 src, uae_u32 dst)
550 + {
551 +        uae_u32 value;
552 +        __asm__ ("\n"
553 +                "       sll             %2, 16, %%o0\n"
554 +                "       sll             %3, 16, %%o1\n"
555 +                "       subcc   %%o0, %%o1, %%o0\n"
556 +                "       rd              %%ccr, %%o1\n"
557 +                "       srl             %%o0, 16, %0\n"
558 +                "       stb             %%o1, [%1]\n"
559 +                "       stb             %%o1, [%1+1]\n"
560 +        :       "=&r" (value)
561 +        :       "r" (flags), "r" (dst), "r" (src)
562 +        :       "cc", "o0", "o1"
563 +        );
564 +        return value;
565 + }
566 +
567 + static inline uae_u32 sparc_v9_flag_sub_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
568 + {
569 +        uae_u32 value;
570 +        __asm__ ("\n"
571 +                "       subcc   %2, %3, %0\n"
572 +                "       rd              %%ccr, %%o0\n"
573 +                "       stb             %%o0, [%1]\n"
574 +                "       stb             %%o0, [%1+1]\n"
575 +        :       "=&r" (value)
576 +        :       "r" (flags), "r" (dst), "r" (src)
577 +        :       "cc", "o0"
578 +        );
579 +        return value;
580 + }
581 +
582 + static inline void sparc_v9_flag_cmp_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
583 + {
584 +        __asm__ ("\n"
585 +                "       sll             %1, 24, %%o0\n"
586 +                "       sll             %2, 24, %%o1\n"
587 +                "       subcc   %%o0, %%o1, %%g0\n"
588 +                "       rd              %%ccr, %%o0\n"
589 +                "       stb             %%o0, [%0]\n"
590 +        :       /* no outputs */
591 +        :       "r" (flags), "r" (dst), "r" (src)
592 +        :       "cc", "o0", "o1"
593 +        );
594 + }
595 +
596 + static inline void sparc_v9_flag_cmp_16(flag_struct *flags, uae_u32 src, uae_u32 dst)
597 + {
598 +        __asm__ ("\n"
599 +                "       sll             %1, 16, %%o0\n"
600 +                "       sll             %2, 16, %%o1\n"
601 +                "       subcc   %%o0, %%o1, %%g0\n"
602 +                "       rd              %%ccr, %%o0\n"
603 +                "       stb             %%o0, [%0]\n"
604 +        :       /* no outputs */
605 +        :       "r" (flags), "r" (dst), "r" (src)
606 +        :       "cc", "o0", "o1"
607 +        );
608 + }
609 +
610 + static inline void sparc_v9_flag_cmp_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
611 + {
612 +        __asm__ ("\n"
613 +                "       subcc   %1, %2, %%g0\n"
614 + #if 0
615 +                "       subcc   %1, %2, %%o1\n"
616 +                "       srl             %%o1, 31, %%o0\n"
617 +                "       sll             %%o0, 3, %%o0\n"
618 +                "       addx    %%o0, %%g0, %%o0\n"
619 +                "       bvs,a   .+8\n"
620 +                "       or              %%o0, 0x02, %%o0\n"
621 +                "       subcc   %%g0, %%o1, %%g0\n"
622 +                "       addx    %%g0, 7, %%o1\n"
623 +                "       and             %%o1, 0x04, %%o1\n"
624 +                "       or              %%o0, %%o1, %%o0\n"
625 + #endif
626 + #if 0
627 +                "       subcc   %1, %2, %%o1\n"
628 +                "       srl             %%o1, 31, %%o0\n"
629 +                "       sll             %%o0, 3, %%o0\n"
630 +                "       addx    %%o0, %%g0, %%o0\n"
631 +                "       bvs,pt,a        .+8\n"
632 +                "       or              %%o0, 0x02, %%o0\n"
633 +                "       subcc   %%g0, %%o1, %%g0\n"
634 +                "       addx    %%g0, 7, %%o1\n"
635 +                "       and             %%o1, 0x04, %%o1\n"
636 +                "       or              %%o0, %%o1, %%o0\n"
637 +                "       stb             %%o0, [%0]\n"
638 + #endif
639 +                "       rd              %%ccr, %%o0\n"
640 +                "       stb             %%o0, [%0]\n"
641 +        :       /* no outputs */
642 +        :       "r" (flags), "r" (dst), "r" (src)
643 +        :       "cc", "o0", "o1"
644 +        );
645 + }
646 +
647 + #if 1
648 + static inline void sparc_v9_flag_test_8(flag_struct *flags, uae_u32 val)
649 + {
650 +        __asm__ ("\n"
651 +                "       sll             %1, 24, %%o0\n"
652 +                "       subcc   %%o0, %%g0, %%g0\n"
653 +                "       rd              %%ccr, %%o0\n"
654 +                "       stb             %%o0, [%0]\n"
655 +        :       /* no outputs */
656 +        :       "r" (flags), "r" (val)
657 +        :       "cc", "o0"
658 +        );
659 + }
660 +
661 + static inline void sparc_v9_flag_test_16(flag_struct *flags, uae_u32 val)
662 + {
663 +        __asm__ ("\n"
664 +                "       sll             %1, 16, %%o0\n"
665 +                "       subcc   %%o0, %%g0, %%g0\n"
666 +                "       rd              %%ccr, %%o0\n"
667 +                "       stb             %%o0, [%0]\n"
668 +        :       /* no outputs */
669 +        :       "r" (flags), "r" (val)
670 +        :       "cc", "o0"
671 +        );
672 + }
673 +
674 + static inline void sparc_v9_flag_test_32(flag_struct *flags, uae_u32 val)
675 + {
676 +        __asm__ ("\n"
677 +                "       subcc   %1, %%g0, %%g0\n"
678 +                "       rd              %%ccr, %%o0\n"
679 +                "       stb             %%o0, [%0]\n"
680 +        :       /* no outputs */
681 +        :       "r" (flags), "r" (val)
682 +        :       "cc", "o0"
683 +        );
684 + }
685 + #else
686 + static inline void sparc_v9_flag_test_8(flag_struct *flags, uae_u32 val)
687 + {
688 +        __asm__ ("\n"
689 +                "       sll             %1, 24, %%o0\n"
690 +                "       subcc   %%o0, %%g0, %%o1\n"
691 +                "       srl             %%o1, 31, %%o0\n"
692 +                "       sll             %%o0, 3, %%o0\n"
693 +                "       addx    %%o0, %%g0, %%o0\n"
694 +                "       bvs,a   .+8\n"
695 +                "       or              %%o0, 0x02, %%o0\n"
696 +                "       subcc   %%g0, %%o1, %%g0\n"
697 +                "       addx    %%g0, 7, %%o1\n"
698 +                "       and             %%o1, 0x04, %%o1\n"
699 +                "       or              %%o0, %%o1, %%o0\n"
700 +                "       stb             %%o0, [%0]\n"
701 +        :       /* no outputs */
702 +        :       "r" (flags), "r" (val)
703 +        :       "cc", "o0", "o1"
704 +        );
705 + }
706 +
707 + static inline void sparc_v9_flag_test_16(flag_struct *flags, uae_u32 val)
708 + {
709 +        __asm__ ("\n"
710 +                "       sll             %1, 16, %%o0\n"
711 +                "       subcc   %%o0, %%g0, %%o1\n"
712 +                "       srl             %%o1, 31, %%o0\n"
713 +                "       sll             %%o0, 3, %%o0\n"
714 +                "       addx    %%o0, %%g0, %%o0\n"
715 +                "       bvs,a   .+8\n"
716 +                "       or              %%o0, 0x02, %%o0\n"
717 +                "       subcc   %%g0, %%o1, %%g0\n"
718 +                "       addx    %%g0, 7, %%o1\n"
719 +                "       and             %%o1, 0x04, %%o1\n"
720 +                "       or              %%o0, %%o1, %%o0\n"
721 +                "       stb             %%o0, [%0]\n"
722 +        :       /* no outputs */
723 +        :       "r" (flags), "r" (val)
724 +        :       "cc", "o0", "o1"
725 +        );
726 + }
727 +
728 + static inline void sparc_v9_flag_test_32(flag_struct *flags, uae_u32 val)
729 + {
730 +        __asm__ ("\n"
731 +                "       subcc   %1, %%g0, %%o1\n"
732 +                "       srl             %%o1, 31, %%o0\n"
733 +                "       sll             %%o0, 3, %%o0\n"
734 +                "       addx    %%o0, %%g0, %%o0\n"
735 +                "       bvs,a   .+8\n"
736 +                "       or              %%o0, 0x02, %%o0\n"
737 +                "       subcc   %%g0, %%o1, %%g0\n"
738 +                "       addx    %%g0, 7, %%o1\n"
739 +                "       and             %%o1, 0x04, %%o1\n"
740 +                "       or              %%o0, %%o1, %%o0\n"
741 +                "       stb             %%o0, [%0]\n"
742 +        :       /* no outputs */
743 +        :       "r" (flags), "r" (val)
744 +        :       "cc", "o0", "o1"
745 +        );
746 + }
747 + #endif
748 +
749 + static inline uae_u32 sparc_v9_flag_addx_8(flag_struct *flags, uae_u32 src, uae_u32 dst)
750 + {
751 +        uae_u32 value;
752 +        __asm__ ("\n"
753 +                "       ldub    [%1 + 1], %%o1          ! Get the X Flag\n"
754 +                "       subcc   %%g0, %%o1, %%g0        ! Set the SPARC carry flag, if X set\n"
755 +                "       addxcc  %2, %3, %0\n"
756 +        :       "=&r" (value)
757 +        :       "r" (flags), "r" (dst), "r" (src)
758 +        :       "cc", "o0", "o1"
759 +        );
760 +        return value;
761 + }
762 +
763 + static inline uae_u32 sparc_v9_flag_addx_32(flag_struct *flags, uae_u32 src, uae_u32 dst)
764 + {
765 +        uae_u32 value;
766 +        __asm__ ("\n"
767 +                "       ldub    [%1 + 1], %%o0          ! Get the X Flag\n"
768 +                "       subcc   %%g0, %%o0, %%g0        ! Set the SPARC carry flag, if X set\n"
769 +                "       addxcc  %2, %3, %0\n"
770 +                "       ldub    [%1], %%o0                      ! retreive the old NZVC flags\n"
771 +                "       and             %%o0, 0x04, %%o0        ! but keep only Z flag\n"
772 +                "       addx    %%o0, %%g0, %%o0        ! X,C flags\n"
773 +                "       bl,a    .+8\n"
774 +                "       or              %%o0, 0x08, %%o0        ! N flag\n"
775 +                "       bvs,a   .+8\n"
776 +                "       or              %%o0, 0x02, %%o0        ! V flag\n"
777 +                "       bnz,a   .+8\n"
778 +                "       and             %%o0, 0x0B, %%o0        ! Z flag cleared if result is non-zero\n"
779 +                "       stb             %%o0, [%1]\n"
780 +                "       stb             %%o0, [%1 + 1]\n"
781 +        :       "=&r" (value)
782 +        :       "r" (flags), "r" (dst), "r" (src)
783 +        :       "cc", "o0"
784 +        );
785 +        return value;
786 + }
787 +
788 + #endif /* SPARC_V9_ASSEMBLY */
789 +
790   #else
791  
792   struct flag_struct {

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines