![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reg_compare.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / emulator|
Return to reg_compare.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / emulator |
1.1 ! root 1: /*---------------------------------------------------------------------------+ ! 2: | reg_compare.c | ! 3: | | ! 4: | Compare two floating point registers | ! 5: | | ! 6: | Copyright (C) 1992 W. Metzenthen, 22 Parker St, Ormond, Vic 3163, | ! 7: | Australia. E-mail [email protected] | ! 8: | | ! 9: | | ! 10: +---------------------------------------------------------------------------*/ ! 11: ! 12: /*---------------------------------------------------------------------------+ ! 13: | compare() is the core FPU_REG comparison function | ! 14: +---------------------------------------------------------------------------*/ ! 15: ! 16: #include "fpu_system.h" ! 17: #include "exception.h" ! 18: #include "fpu_emu.h" ! 19: #include "status_w.h" ! 20: ! 21: ! 22: int emCompare(FPU_REG *b) ! 23: { ! 24: int diff; ! 25: ! 26: if ( FPU_st0_ptr->tag | b->tag ) ! 27: { ! 28: if ( FPU_st0_ptr->tag == TW_Zero ) ! 29: { ! 30: if ( b->tag == TW_Zero ) return COMP_A_EQ_B; ! 31: if ( b->tag == TW_Valid ) ! 32: { ! 33: return (b->sign == SIGN_POS) ? COMP_A_LT_B : COMP_A_GT_B ; ! 34: } ! 35: } ! 36: else if ( b->tag == TW_Zero ) ! 37: { ! 38: if ( FPU_st0_ptr->tag == TW_Valid ) ! 39: { ! 40: return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_GT_B : COMP_A_LT_B ; ! 41: } ! 42: } ! 43: ! 44: if ( FPU_st0_ptr->tag == TW_Infinity ) ! 45: { ! 46: if ( (b->tag == TW_Valid) || (b->tag == TW_Zero) ) ! 47: { ! 48: return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_GT_B : COMP_A_LT_B; ! 49: } ! 50: else if ( b->tag == TW_Infinity ) ! 51: { ! 52: /* The 80486 book says that infinities can be equal! */ ! 53: return (FPU_st0_ptr->sign == b->sign) ? COMP_A_EQ_B : ! 54: ((FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_GT_B : COMP_A_LT_B); ! 55: } ! 56: /* Fall through to the NaN code */ ! 57: } ! 58: else if ( b->tag == TW_Infinity ) ! 59: { ! 60: if ( (FPU_st0_ptr->tag == TW_Valid) || (FPU_st0_ptr->tag == TW_Zero) ) ! 61: { ! 62: return (b->sign == SIGN_POS) ? COMP_A_LT_B : COMP_A_GT_B; ! 63: } ! 64: /* Fall through to the NaN code */ ! 65: } ! 66: ! 67: /* The only possibility now should be that one of the arguments ! 68: is a NaN */ ! 69: if ( (FPU_st0_ptr->tag == TW_NaN) || (b->tag == TW_NaN) ) ! 70: { ! 71: if ( ((FPU_st0_ptr->tag == TW_NaN) && !(FPU_st0_ptr->sigh & 0x40000000)) ! 72: || ((b->tag == TW_NaN) && !(b->sigh & 0x40000000)) ) ! 73: /* At least one arg is a signaling NaN */ ! 74: return COMP_NOCOMP | COMP_SNAN | COMP_NAN; ! 75: else ! 76: /* Neither is a signaling NaN */ ! 77: return COMP_NOCOMP | COMP_NAN; ! 78: } ! 79: ! 80: EXCEPTION(EX_Invalid); ! 81: } ! 82: ! 83: #ifdef PARANOID ! 84: if (!(FPU_st0_ptr->sigh & 0x80000000)) EXCEPTION(EX_Invalid); ! 85: if (!(b->sigh & 0x80000000)) EXCEPTION(EX_Invalid); ! 86: #endif PARANOID ! 87: ! 88: if (FPU_st0_ptr->sign != b->sign) ! 89: return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_GT_B : COMP_A_LT_B; ! 90: ! 91: diff = FPU_st0_ptr->exp - b->exp; ! 92: if ( diff == 0 ) ! 93: { ! 94: diff = FPU_st0_ptr->sigh - b->sigh; ! 95: if ( diff == 0 ) ! 96: diff = FPU_st0_ptr->sigl - b->sigl; ! 97: } ! 98: ! 99: if ( diff > 0 ) ! 100: return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_GT_B : COMP_A_LT_B ; ! 101: if ( diff < 0 ) ! 102: return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_LT_B : COMP_A_GT_B ; ! 103: return COMP_A_EQ_B; ! 104: ! 105: } ! 106: ! 107: ! 108: void compare_st_data(void) ! 109: { ! 110: int f; ! 111: int c = emCompare(&FPU_loaded_data); ! 112: ! 113: if (c & COMP_NAN) ! 114: { ! 115: EXCEPTION(EX_Invalid); ! 116: f = SW_C3 | SW_C2 | SW_C0; ! 117: } ! 118: else ! 119: switch (c) ! 120: { ! 121: case COMP_A_LT_B: ! 122: f = SW_C0; ! 123: break; ! 124: case COMP_A_EQ_B: ! 125: f = SW_C3; ! 126: break; ! 127: case COMP_A_GT_B: ! 128: f = 0; ! 129: break; ! 130: case COMP_NOCOMP: ! 131: f = SW_C3 | SW_C2 | SW_C0; ! 132: break; ! 133: #ifdef PARANOID ! 134: default: ! 135: EXCEPTION(EX_INTERNAL|0x121); ! 136: f = SW_C3 | SW_C2 | SW_C0; ! 137: break; ! 138: #endif PARANOID ! 139: } ! 140: setcc(f); ! 141: } ! 142: ! 143: ! 144: static void compare_st_st(int nr) ! 145: { ! 146: int c = emCompare(&st(nr)); ! 147: int f; ! 148: if (c & COMP_NAN) ! 149: { ! 150: EXCEPTION(EX_Invalid); ! 151: f = SW_C3 | SW_C2 | SW_C0; ! 152: } ! 153: else ! 154: switch (c) ! 155: { ! 156: case COMP_A_LT_B: ! 157: f = SW_C0; ! 158: break; ! 159: case COMP_A_EQ_B: ! 160: f = SW_C3; ! 161: break; ! 162: case COMP_A_GT_B: ! 163: f = 0; ! 164: break; ! 165: case COMP_NOCOMP: ! 166: f = SW_C3 | SW_C2 | SW_C0; ! 167: break; ! 168: #ifdef PARANOID ! 169: default: ! 170: EXCEPTION(EX_INTERNAL|0x122); ! 171: f = SW_C3 | SW_C2 | SW_C0; ! 172: break; ! 173: #endif PARANOID ! 174: } ! 175: setcc(f); ! 176: } ! 177: ! 178: ! 179: static void compare_u_st_st(int nr) ! 180: { ! 181: int f; ! 182: int c = emCompare(&st(nr)); ! 183: if (c & COMP_NAN) ! 184: { ! 185: if (c & COMP_SNAN) /* This is the only difference between ! 186: un-ordered and ordinary comparisons */ ! 187: EXCEPTION(EX_Invalid); ! 188: f = SW_C3 | SW_C2 | SW_C0; ! 189: } ! 190: else ! 191: switch (c) ! 192: { ! 193: case COMP_A_LT_B: ! 194: f = SW_C0; ! 195: break; ! 196: case COMP_A_EQ_B: ! 197: f = SW_C3; ! 198: break; ! 199: case COMP_A_GT_B: ! 200: f = 0; ! 201: break; ! 202: case COMP_NOCOMP: ! 203: f = SW_C3 | SW_C2 | SW_C0; ! 204: break; ! 205: #ifdef PARANOID ! 206: default: ! 207: EXCEPTION(EX_INTERNAL|0x123); ! 208: f = SW_C3 | SW_C2 | SW_C0; ! 209: break; ! 210: #endif PARANOID ! 211: } ! 212: setcc(f); ! 213: } ! 214: ! 215: /*---------------------------------------------------------------------------*/ ! 216: ! 217: void fcom_st() ! 218: { ! 219: /* fcom st(i) */ ! 220: compare_st_st(FPU_rm); ! 221: } ! 222: ! 223: ! 224: void fcompst() ! 225: { ! 226: /* fcomp st(i) */ ! 227: compare_st_st(FPU_rm); ! 228: pop(); ! 229: } ! 230: ! 231: ! 232: void fcompp() ! 233: { ! 234: /* fcompp */ ! 235: if (FPU_rm != 1) ! 236: return Un_impl(); ! 237: compare_st_st(1); ! 238: pop(); FPU_st0_ptr = &st(0); ! 239: pop(); ! 240: } ! 241: ! 242: ! 243: void fucom_() ! 244: { ! 245: /* fucom st(i) */ ! 246: compare_u_st_st(FPU_rm); ! 247: } ! 248: ! 249: ! 250: void fucomp() ! 251: { ! 252: /* fucomp st(i) */ ! 253: compare_u_st_st(FPU_rm); ! 254: pop(); ! 255: } ! 256: ! 257: ! 258: void fucompp() ! 259: { ! 260: /* fucompp */ ! 261: if (FPU_rm == 1) ! 262: { ! 263: compare_u_st_st(1); ! 264: pop(); FPU_st0_ptr = &st(0); ! 265: pop(); ! 266: } ! 267: else ! 268: Un_impl(); ! 269: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.