Annotation of sys/arch/hppa/spmath/float.h, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: float.h,v 1.7 2004/01/02 14:39:01 mickey Exp $ */
! 2: /*
! 3: (c) Copyright 1986 HEWLETT-PACKARD COMPANY
! 4: To anyone who acknowledges that this file is provided "AS IS"
! 5: without any express or implied warranty:
! 6: permission to use, copy, modify, and distribute this file
! 7: for any purpose is hereby granted without fee, provided that
! 8: the above copyright notice and this notice appears in all
! 9: copies, and that the name of Hewlett-Packard Company not be
! 10: used in advertising or publicity pertaining to distribution
! 11: of the software without specific, written prior permission.
! 12: Hewlett-Packard Company makes no representations about the
! 13: suitability of this software for any purpose.
! 14: */
! 15: /* @(#)float.h: Revision: 2.14.88.2 Date: 93/12/08 13:27:42 */
! 16:
! 17: #include <machine/float.h>
! 18: #include "fpbits.h"
! 19: #include "hppa.h"
! 20:
! 21: /*
! 22: * Declare the basic structures for the 3 different
! 23: * floating-point precisions.
! 24: *
! 25: * Single number
! 26: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 27: * |s| exp | mantissa |
! 28: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 29: */
! 30: #define Sall(object) (object)
! 31: #define Ssign(object) Bitfield_extract( 0, 1,object)
! 32: #define Ssignedsign(object) Bitfield_signed_extract( 0, 1,object)
! 33: #define Sexponent(object) Bitfield_extract( 1, 8,object)
! 34: #define Smantissa(object) Bitfield_mask( 9, 23,object)
! 35: #define Ssignaling(object) Bitfield_extract( 9, 1,object)
! 36: #define Ssignalingnan(object) Bitfield_extract( 1, 9,object)
! 37: #define Shigh2mantissa(object) Bitfield_extract( 9, 2,object)
! 38: #define Sexponentmantissa(object) Bitfield_mask( 1, 31,object)
! 39: #define Ssignexponent(object) Bitfield_extract( 0, 9,object)
! 40: #define Shidden(object) Bitfield_extract( 8, 1,object)
! 41: #define Shiddenoverflow(object) Bitfield_extract( 7, 1,object)
! 42: #define Shiddenhigh7mantissa(object) Bitfield_extract( 8, 8,object)
! 43: #define Shiddenhigh3mantissa(object) Bitfield_extract( 8, 4,object)
! 44: #define Slow(object) Bitfield_mask( 31, 1,object)
! 45: #define Slow4(object) Bitfield_mask( 28, 4,object)
! 46: #define Slow31(object) Bitfield_mask( 1, 31,object)
! 47: #define Shigh31(object) Bitfield_extract( 0, 31,object)
! 48: #define Ssignedhigh31(object) Bitfield_signed_extract( 0, 31,object)
! 49: #define Shigh4(object) Bitfield_extract( 0, 4,object)
! 50: #define Sbit24(object) Bitfield_extract( 24, 1,object)
! 51: #define Sbit28(object) Bitfield_extract( 28, 1,object)
! 52: #define Sbit29(object) Bitfield_extract( 29, 1,object)
! 53: #define Sbit30(object) Bitfield_extract( 30, 1,object)
! 54: #define Sbit31(object) Bitfield_mask( 31, 1,object)
! 55:
! 56: #define Deposit_ssign(object,value) Bitfield_deposit(value,0,1,object)
! 57: #define Deposit_sexponent(object,value) Bitfield_deposit(value,1,8,object)
! 58: #define Deposit_smantissa(object,value) Bitfield_deposit(value,9,23,object)
! 59: #define Deposit_shigh2mantissa(object,value) Bitfield_deposit(value,9,2,object)
! 60: #define Deposit_sexponentmantissa(object,value) \
! 61: Bitfield_deposit(value,1,31,object)
! 62: #define Deposit_ssignexponent(object,value) Bitfield_deposit(value,0,9,object)
! 63: #define Deposit_slow(object,value) Bitfield_deposit(value,31,1,object)
! 64: #define Deposit_shigh4(object,value) Bitfield_deposit(value,0,4,object)
! 65:
! 66: #define Is_ssign(object) Bitfield_mask( 0, 1,object)
! 67: #define Is_ssignaling(object) Bitfield_mask( 9, 1,object)
! 68: #define Is_shidden(object) Bitfield_mask( 8, 1,object)
! 69: #define Is_shiddenoverflow(object) Bitfield_mask( 7, 1,object)
! 70: #define Is_slow(object) Bitfield_mask( 31, 1,object)
! 71: #define Is_sbit24(object) Bitfield_mask( 24, 1,object)
! 72: #define Is_sbit28(object) Bitfield_mask( 28, 1,object)
! 73: #define Is_sbit29(object) Bitfield_mask( 29, 1,object)
! 74: #define Is_sbit30(object) Bitfield_mask( 30, 1,object)
! 75: #define Is_sbit31(object) Bitfield_mask( 31, 1,object)
! 76:
! 77: /*
! 78: * Double number.
! 79: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 80: * |s| exponent | mantissa part 1 |
! 81: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 82: *
! 83: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 84: * | mantissa part 2 |
! 85: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 86: */
! 87: #define Dallp1(object) (object)
! 88: #define Dsign(object) Bitfield_extract( 0, 1,object)
! 89: #define Dsignedsign(object) Bitfield_signed_extract( 0, 1,object)
! 90: #define Dexponent(object) Bitfield_extract( 1, 11,object)
! 91: #define Dmantissap1(object) Bitfield_mask( 12, 20,object)
! 92: #define Dsignaling(object) Bitfield_extract( 12, 1,object)
! 93: #define Dsignalingnan(object) Bitfield_extract( 1, 12,object)
! 94: #define Dhigh2mantissa(object) Bitfield_extract( 12, 2,object)
! 95: #define Dexponentmantissap1(object) Bitfield_mask( 1, 31,object)
! 96: #define Dsignexponent(object) Bitfield_extract( 0, 12,object)
! 97: #define Dhidden(object) Bitfield_extract( 11, 1,object)
! 98: #define Dhiddenoverflow(object) Bitfield_extract( 10, 1,object)
! 99: #define Dhiddenhigh7mantissa(object) Bitfield_extract( 11, 8,object)
! 100: #define Dhiddenhigh3mantissa(object) Bitfield_extract( 11, 4,object)
! 101: #define Dlowp1(object) Bitfield_mask( 31, 1,object)
! 102: #define Dlow31p1(object) Bitfield_mask( 1, 31,object)
! 103: #define Dhighp1(object) Bitfield_extract( 0, 1,object)
! 104: #define Dhigh4p1(object) Bitfield_extract( 0, 4,object)
! 105: #define Dhigh31p1(object) Bitfield_extract( 0, 31,object)
! 106: #define Dsignedhigh31p1(object) Bitfield_signed_extract( 0, 31,object)
! 107: #define Dbit3p1(object) Bitfield_extract( 3, 1,object)
! 108:
! 109: #define Deposit_dsign(object,value) Bitfield_deposit(value,0,1,object)
! 110: #define Deposit_dexponent(object,value) Bitfield_deposit(value,1,11,object)
! 111: #define Deposit_dmantissap1(object,value) Bitfield_deposit(value,12,20,object)
! 112: #define Deposit_dhigh2mantissa(object,value) Bitfield_deposit(value,12,2,object)
! 113: #define Deposit_dexponentmantissap1(object,value) \
! 114: Bitfield_deposit(value,1,31,object)
! 115: #define Deposit_dsignexponent(object,value) Bitfield_deposit(value,0,12,object)
! 116: #define Deposit_dlowp1(object,value) Bitfield_deposit(value,31,1,object)
! 117: #define Deposit_dhigh4p1(object,value) Bitfield_deposit(value,0,4,object)
! 118:
! 119: #define Is_dsign(object) Bitfield_mask( 0, 1,object)
! 120: #define Is_dsignaling(object) Bitfield_mask( 12, 1,object)
! 121: #define Is_dhidden(object) Bitfield_mask( 11, 1,object)
! 122: #define Is_dhiddenoverflow(object) Bitfield_mask( 10, 1,object)
! 123: #define Is_dlowp1(object) Bitfield_mask( 31, 1,object)
! 124: #define Is_dhighp1(object) Bitfield_mask( 0, 1,object)
! 125: #define Is_dbit3p1(object) Bitfield_mask( 3, 1,object)
! 126:
! 127: #define Dallp2(object) (object)
! 128: #define Dmantissap2(object) (object)
! 129: #define Dlowp2(object) Bitfield_mask( 31, 1,object)
! 130: #define Dlow4p2(object) Bitfield_mask( 28, 4,object)
! 131: #define Dlow31p2(object) Bitfield_mask( 1, 31,object)
! 132: #define Dhighp2(object) Bitfield_extract( 0, 1,object)
! 133: #define Dhigh31p2(object) Bitfield_extract( 0, 31,object)
! 134: #define Dbit2p2(object) Bitfield_extract( 2, 1,object)
! 135: #define Dbit3p2(object) Bitfield_extract( 3, 1,object)
! 136: #define Dbit21p2(object) Bitfield_extract( 21, 1,object)
! 137: #define Dbit28p2(object) Bitfield_extract( 28, 1,object)
! 138: #define Dbit29p2(object) Bitfield_extract( 29, 1,object)
! 139: #define Dbit30p2(object) Bitfield_extract( 30, 1,object)
! 140: #define Dbit31p2(object) Bitfield_mask( 31, 1,object)
! 141:
! 142: #define Deposit_dlowp2(object,value) Bitfield_deposit(value,31,1,object)
! 143:
! 144: #define Is_dlowp2(object) Bitfield_mask( 31, 1,object)
! 145: #define Is_dhighp2(object) Bitfield_mask( 0, 1,object)
! 146: #define Is_dbit2p2(object) Bitfield_mask( 2, 1,object)
! 147: #define Is_dbit3p2(object) Bitfield_mask( 3, 1,object)
! 148: #define Is_dbit21p2(object) Bitfield_mask( 21, 1,object)
! 149: #define Is_dbit28p2(object) Bitfield_mask( 28, 1,object)
! 150: #define Is_dbit29p2(object) Bitfield_mask( 29, 1,object)
! 151: #define Is_dbit30p2(object) Bitfield_mask( 30, 1,object)
! 152: #define Is_dbit31p2(object) Bitfield_mask( 31, 1,object)
! 153:
! 154: /*
! 155: * Quad number.
! 156: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 157: * |s| exponent | mantissa part 1 |
! 158: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 159: *
! 160: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 161: * | mantissa part 2 |
! 162: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 163: *
! 164: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 165: * | mantissa part 3 |
! 166: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 167: *
! 168: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 169: * | mantissa part 4 |
! 170: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 171: */
! 172: typedef struct
! 173: {
! 174: union
! 175: {
! 176: struct { unsigned qallp1; } u_qallp1;
! 177: /* Not needed for now...
! 178: Bitfield_extract( 0, 1,u_qsign,qsign)
! 179: Bitfield_signed_extract( 0, 1,u_qsignedsign,qsignedsign)
! 180: Bitfield_extract( 1, 15,u_qexponent,qexponent)
! 181: Bitfield_extract(16, 16,u_qmantissap1,qmantissap1)
! 182: Bitfield_extract(16, 1,u_qsignaling,qsignaling)
! 183: Bitfield_extract(1, 16,u_qsignalingnan,qsignalingnan)
! 184: Bitfield_extract(16, 2,u_qhigh2mantissa,qhigh2mantissa)
! 185: Bitfield_extract( 1, 31,u_qexponentmantissap1,qexponentmantissap1)
! 186: Bitfield_extract( 0, 16,u_qsignexponent,qsignexponent)
! 187: Bitfield_extract(15, 1,u_qhidden,qhidden)
! 188: Bitfield_extract(14, 1,u_qhiddenoverflow,qhiddenoverflow)
! 189: Bitfield_extract(15, 8,u_qhiddenhigh7mantissa,qhiddenhigh7mantissa)
! 190: Bitfield_extract(15, 4,u_qhiddenhigh3mantissa,qhiddenhigh3mantissa)
! 191: Bitfield_extract(31, 1,u_qlowp1,qlowp1)
! 192: Bitfield_extract( 1, 31,u_qlow31p1,qlow31p1)
! 193: Bitfield_extract( 0, 1,u_qhighp1,qhighp1)
! 194: Bitfield_extract( 0, 4,u_qhigh4p1,qhigh4p1)
! 195: Bitfield_extract( 0, 31,u_qhigh31p1,qhigh31p1)
! 196: */
! 197: } quad_u1;
! 198: union
! 199: {
! 200: struct { unsigned qallp2; } u_qallp2;
! 201: /* Not needed for now...
! 202: Bitfield_extract(31, 1,u_qlowp2,qlowp2)
! 203: Bitfield_extract( 1, 31,u_qlow31p2,qlow31p2)
! 204: Bitfield_extract( 0, 1,u_qhighp2,qhighp2)
! 205: Bitfield_extract( 0, 31,u_qhigh31p2,qhigh31p2)
! 206: */
! 207: } quad_u2;
! 208: union
! 209: {
! 210: struct { unsigned qallp3; } u_qallp3;
! 211: /* Not needed for now...
! 212: Bitfield_extract(31, 1,u_qlowp3,qlowp3)
! 213: Bitfield_extract( 1, 31,u_qlow31p3,qlow31p3)
! 214: Bitfield_extract( 0, 1,u_qhighp3,qhighp3)
! 215: Bitfield_extract( 0, 31,u_qhigh31p3,qhigh31p3)
! 216: */
! 217: } quad_u3;
! 218: union
! 219: {
! 220: struct { unsigned qallp4; } u_qallp4;
! 221: /* Not need for now...
! 222: Bitfield_extract(31, 1,u_qlowp4,qlowp4)
! 223: Bitfield_extract( 1, 31,u_qlow31p4,qlow31p4)
! 224: Bitfield_extract( 0, 1,u_qhighp4,qhighp4)
! 225: Bitfield_extract( 0, 31,u_qhigh31p4,qhigh31p4)
! 226: */
! 227: } quad_u4;
! 228: } quad_floating_point;
! 229:
! 230: /* Extension - An additional structure to hold the guard, round and
! 231: * sticky bits during computations.
! 232: */
! 233: #define Extall(object) (object)
! 234: #define Extsign(object) Bitfield_extract( 0, 1,object)
! 235: #define Exthigh31(object) Bitfield_extract( 0, 31,object)
! 236: #define Extlow31(object) Bitfield_extract( 1, 31,object)
! 237: #define Extlow(object) Bitfield_extract( 31, 1,object)
! 238:
! 239: /*
! 240: * Declare the basic structures for the 3 different
! 241: * fixed-point precisions.
! 242: *
! 243: * Single number
! 244: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 245: * |s| integer |
! 246: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 247: */
! 248: typedef int sgl_integer;
! 249:
! 250: /*
! 251: * Double number.
! 252: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 253: * |s| high integer |
! 254: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 255: *
! 256: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 257: * | low integer |
! 258: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 259: */
! 260: struct dint {
! 261: int wd0;
! 262: unsigned int wd1;
! 263: };
! 264:
! 265: struct dblwd {
! 266: unsigned int wd0;
! 267: unsigned int wd1;
! 268: };
! 269:
! 270: /*
! 271: * Quad number.
! 272: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 273: * |s| integer part1 |
! 274: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 275: *
! 276: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 277: * | integer part 2 |
! 278: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 279: *
! 280: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 281: * | integer part 3 |
! 282: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 283: *
! 284: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 285: * | integer part 4 |
! 286: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 287: */
! 288:
! 289: struct quadwd {
! 290: int wd0;
! 291: unsigned int wd1;
! 292: unsigned int wd2;
! 293: unsigned int wd3;
! 294: };
! 295:
! 296: typedef struct quadwd quad_integer;
! 297:
! 298:
! 299: /* useful typedefs */
! 300: typedef int sgl_floating_point;
! 301: typedef struct dblwd dbl_floating_point;
! 302: typedef struct dint dbl_integer;
! 303:
! 304: /*
! 305: * Define the different precisions' parameters.
! 306: */
! 307: #define SGL_BITLENGTH 32
! 308: #define SGL_EMAX 127
! 309: #define SGL_BIAS 127
! 310: #define SGL_WRAP 192
! 311: #define SGL_INFINITY_EXPONENT (SGL_EMAX+SGL_BIAS+1)
! 312: #define SGL_THRESHOLD 32
! 313: #define SGL_EXP_LENGTH 8
! 314: #define SGL_P 24
! 315:
! 316: #define DBL_BITLENGTH 64
! 317: #define DBL_EMAX 1023
! 318: #define DBL_BIAS 1023
! 319: #define DBL_WRAP 1536
! 320: #define DBL_INFINITY_EXPONENT (DBL_EMAX+DBL_BIAS+1)
! 321: #define DBL_THRESHOLD 64
! 322: #define DBL_EXP_LENGTH 11
! 323: #define DBL_P 53
! 324:
! 325: #define QUAD_BITLENGTH 128
! 326: #define QUAD_EMAX 16383
! 327: #define QUAD_BIAS 16383
! 328: #define QUAD_WRAP 24576
! 329: #define QUAD_INFINITY_EXPONENT (QUAD_EMAX+QUAD_BIAS+1)
! 330: #define QUAD_P 113
! 331:
! 332: /* Boolean Values etc. */
! 333: #define FALSE 0
! 334: #define TRUE (!FALSE)
! 335: #define NOT !
! 336: #define XOR ^
! 337:
! 338: /* Declare status register equivalent to FPUs architecture.
! 339: *
! 340: * 0 1 2 3 4 5 6 7 8 910 1 2 3 4 5 6 7 8 920 1 2 3 4 5 6 7 8 930 1
! 341: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 342: * |V|Z|O|U|I|C| rsv | model | version |RM |rsv|T|r|V|Z|O|U|I|
! 343: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 344: */
! 345: #define Cbit(object) Bitfield_extract( 5, 1,object)
! 346: #define Tbit(object) Bitfield_extract( 25, 1,object)
! 347: #define Roundingmode(object) Bitfield_extract( 21, 2,object)
! 348: #define Invalidtrap(object) Bitfield_extract( 27, 1,object)
! 349: #define Divisionbyzerotrap(object) Bitfield_extract( 28, 1,object)
! 350: #define Overflowtrap(object) Bitfield_extract( 29, 1,object)
! 351: #define Underflowtrap(object) Bitfield_extract( 30, 1,object)
! 352: #define Inexacttrap(object) Bitfield_extract( 31, 1,object)
! 353: #define Invalidflag(object) Bitfield_extract( 0, 1,object)
! 354: #define Divisionbyzeroflag(object) Bitfield_extract( 1, 1,object)
! 355: #define Overflowflag(object) Bitfield_extract( 2, 1,object)
! 356: #define Underflowflag(object) Bitfield_extract( 3, 1,object)
! 357: #define Inexactflag(object) Bitfield_extract( 4, 1,object)
! 358: #define Allflags(object) Bitfield_extract( 0, 5,object)
! 359:
! 360: /* Definitions relevant to the status register */
! 361:
! 362: /* Rounding Modes */
! 363: #define ROUNDNEAREST 0
! 364: #define ROUNDZERO 1
! 365: #define ROUNDPLUS 2
! 366: #define ROUNDMINUS 3
! 367:
! 368: /* Exceptions */
! 369: #define NOEXCEPTION 0x0
! 370: #define INVALIDEXCEPTION 0x20
! 371: #define DIVISIONBYZEROEXCEPTION 0x10
! 372: #define OVERFLOWEXCEPTION 0x08
! 373: #define UNDERFLOWEXCEPTION 0x04
! 374: #define INEXACTEXCEPTION 0x02
! 375: #define UNIMPLEMENTEDEXCEPTION 0x01
! 376:
! 377: /* Declare exception registers equivalent to FPUs architecture
! 378: *
! 379: * 0 1 2 3 4 5 6 7 8 910 1 2 3 4 5 6 7 8 920 1 2 3 4 5 6 7 8 930 1
! 380: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 381: * |excepttype | r1 | r2/ext | operation |parm |n| t/cond |
! 382: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 383: */
! 384: #define Allexception(object) (object)
! 385: #define Exceptiontype(object) Bitfield_extract( 0, 6,object)
! 386: #define Instructionfield(object) Bitfield_mask( 6,26,object)
! 387: #define Parmfield(object) Bitfield_extract( 23, 3,object)
! 388: #define Rabit(object) Bitfield_extract( 24, 1,object)
! 389: #define Ibit(object) Bitfield_extract( 25, 1,object)
! 390:
! 391: #define Set_exceptiontype(object,value) Bitfield_deposit(value, 0, 6,object)
! 392: #define Set_parmfield(object,value) Bitfield_deposit(value, 23, 3,object)
! 393: #define Set_exceptiontype_and_instr_field(exception,instruction,object) \
! 394: object = ((exception) << 26) | (instruction)
! 395:
! 396: /* Declare the condition field
! 397: *
! 398: * 0 1 2 3 4 5 6 7 8 910 1 2 3 4 5 6 7 8 920 1 2 3 4 5 6 7 8 930 1
! 399: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 400: * | |G|L|E|U|X|
! 401: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 402: */
! 403: #define Allexception(object) (object)
! 404: #define Greaterthanbit(object) Bitfield_extract( 27, 1,object)
! 405: #define Lessthanbit(object) Bitfield_extract( 28, 1,object)
! 406: #define Equalbit(object) Bitfield_extract( 29, 1,object)
! 407: #define Unorderedbit(object) Bitfield_extract( 30, 1,object)
! 408: #define Exceptionbit(object) Bitfield_extract( 31, 1,object)
! 409:
! 410: /* An alias name for the status register */
! 411: #define Fpustatus_register (*status)
! 412:
! 413: /**************************************************
! 414: * Status register referencing and manipulation. *
! 415: **************************************************/
! 416:
! 417: /* Rounding mode */
! 418: #define Rounding_mode() Roundingmode(Fpustatus_register)
! 419: #define Is_rounding_mode(rmode) \
! 420: (Roundingmode(Fpustatus_register) == rmode)
! 421: #define Set_rounding_mode(value) \
! 422: Bitfield_deposit(value,21,2,Fpustatus_register)
! 423:
! 424: /* Boolean testing of the trap enable bits */
! 425: #define Is_invalidtrap_enabled() Invalidtrap(Fpustatus_register)
! 426: #define Is_divisionbyzerotrap_enabled() Divisionbyzerotrap(Fpustatus_register)
! 427: #define Is_overflowtrap_enabled() Overflowtrap(Fpustatus_register)
! 428: #define Is_underflowtrap_enabled() Underflowtrap(Fpustatus_register)
! 429: #define Is_inexacttrap_enabled() Inexacttrap(Fpustatus_register)
! 430:
! 431: /* Set the indicated flags in the status register */
! 432: #define Set_invalidflag() Bitfield_deposit(1,0,1,Fpustatus_register)
! 433: #define Set_divisionbyzeroflag() Bitfield_deposit(1,1,1,Fpustatus_register)
! 434: #define Set_overflowflag() Bitfield_deposit(1,2,1,Fpustatus_register)
! 435: #define Set_underflowflag() Bitfield_deposit(1,3,1,Fpustatus_register)
! 436: #define Set_inexactflag() Bitfield_deposit(1,4,1,Fpustatus_register)
! 437:
! 438: #define Clear_all_flags() Bitfield_deposit(0,0,5,Fpustatus_register)
! 439:
! 440: /* Manipulate the trap and condition code bits (tbit and cbit) */
! 441: #define Set_tbit() Bitfield_deposit(1,25,1,Fpustatus_register)
! 442: #define Clear_tbit() Bitfield_deposit(0,25,1,Fpustatus_register)
! 443: #define Is_tbit_set() Tbit(Fpustatus_register)
! 444: #define Is_cbit_set() Cbit(Fpustatus_register)
! 445:
! 446: #ifdef TIMEX
! 447: #define Set_status_cbit(value) \
! 448: Bitfield_deposit(Bitfield_extract(10,10,Fpustatus_register),11,10,Fpustatus_register); \
! 449: Bitfield_deposit(Bitfield_extract(5,1,Fpustatus_register),10,1,Fpustatus_register); \
! 450: Bitfield_deposit(value,5,1,Fpustatus_register)
! 451: #else
! 452: #define Set_status_cbit(value) Bitfield_deposit(value,5,1,Fpustatus_register)
! 453: #endif
! 454:
! 455: /*******************************
! 456: * Condition field referencing *
! 457: *******************************/
! 458: #define Unordered(cond) Unorderedbit(cond)
! 459: #define Equal(cond) Equalbit(cond)
! 460: #define Lessthan(cond) Lessthanbit(cond)
! 461: #define Greaterthan(cond) Greaterthanbit(cond)
! 462: #define Exception(cond) Exceptionbit(cond)
! 463:
! 464:
! 465: /* Defines for the extension */
! 466: #define Ext_isone_sign(extent) (Extsign(extent))
! 467: #define Ext_isnotzero(extent) \
! 468: (Extall(extent))
! 469: #define Ext_isnotzero_lower(extent) \
! 470: (Extlow31(extent))
! 471: #define Ext_leftshiftby1(extent) \
! 472: Extall(extent) <<= 1
! 473: #define Ext_negate(extent) \
! 474: (int )Extall(extent) = 0 - (int )Extall(extent)
! 475: #define Ext_setone_low(extent) Bitfield_deposit(1,31,1,extent)
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to float.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath