release/src-rt-6.x/linux/linux-2.6/arch/i386/math-emu/reg_ld_str.c

   1 /*---------------------------------------------------------------------------+
   2  |  reg_ld_str.c                                                             |
   3  |                                                                           |
   4  | All of the functions which transfer data between user memory and FPU_REGs.|
   5  |                                                                           |
   6  | Copyright (C) 1992,1993,1994,1996,1997                                    |
   7  |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
   8  |                  E-mail   billm@suburbia.net                              |
   9  |                                                                           |
  10  |                                                                           |
  11  +---------------------------------------------------------------------------*/
  12
  13 /*---------------------------------------------------------------------------+
  14  | Note:                                                                     |
  15  |    The file contains code which accesses user memory.                     |
  16  |    Emulator static data may change when user memory is accessed, due to   |
  17  |    other processes using the emulator while swapping is in progress.      |
  18  +---------------------------------------------------------------------------*/
  19
  20 #include "fpu_emu.h"
  21
  22 #include <asm/uaccess.h>
  23
  24 #include "fpu_system.h"
  25 #include "exception.h"
  26 #include "reg_constant.h"
  27 #include "control_w.h"
  28 #include "status_w.h"
  29
  30
  31 #define DOUBLE_Emax 1023         /* largest valid exponent */
  32 #define DOUBLE_Ebias 1023
  33 #define DOUBLE_Emin (-1022)      /* smallest valid exponent */
  34
  35 #define SINGLE_Emax 127          /* largest valid exponent */
  36 #define SINGLE_Ebias 127
  37 #define SINGLE_Emin (-126)       /* smallest valid exponent */
  38
  39
  40 static u_char normalize_no_excep(FPU_REG *r, int exp, int sign)
  41 {
  42   u_char tag;
  43
  44   setexponent16(r, exp);
  45
  46   tag = FPU_normalize_nuo(r);
  47   stdexp(r);
  48   if ( sign )
  49     setnegative(r);
  50
  51   return tag;
  52 }
  53
  54
  55 int FPU_tagof(FPU_REG *ptr)
  56 {
  57   int exp;
  58
  59   exp = exponent16(ptr) & 0x7fff;
  60   if ( exp == 0 )
  61     {
  62       if ( !(ptr->sigh | ptr->sigl) )
  63         {
  64           return TAG_Zero;
  65         }
  66       /* The number is a de-normal or pseudodenormal. */
  67       return TAG_Special;
  68     }
  69
  70   if ( exp == 0x7fff )
  71     {
  72       /* Is an Infinity, a NaN, or an unsupported data type. */
  73       return TAG_Special;
  74     }
  75
  76   if ( !(ptr->sigh & 0x80000000) )
  77     {
  78       /* Unsupported data type. */
  79       /* Valid numbers have the ms bit set to 1. */
  80       /* Unnormal. */
  81       return TAG_Special;
  82     }
  83
  84   return TAG_Valid;
  85 }
  86
  87
  88 /* Get a long double from user memory */
  89 int FPU_load_extended(long double __user *s, int stnr)
  90 {
  91   FPU_REG *sti_ptr = &st(stnr);
  92
  93   RE_ENTRANT_CHECK_OFF;
  94   FPU_access_ok(VERIFY_READ, s, 10);
  95   __copy_from_user(sti_ptr, s, 10);
  96   RE_ENTRANT_CHECK_ON;
  97
  98   return FPU_tagof(sti_ptr);
  99 }
 100
 101
 102 /* Get a double from user memory */
 103 int FPU_load_double(double __user *dfloat, FPU_REG *loaded_data)
 104 {
 105   int exp, tag, negative;
 106   unsigned m64, l64;
 107
 108   RE_ENTRANT_CHECK_OFF;
 109   FPU_access_ok(VERIFY_READ, dfloat, 8);
 110   FPU_get_user(m64, 1 + (unsigned long __user *) dfloat);
 111   FPU_get_user(l64, (unsigned long __user *) dfloat);
 112   RE_ENTRANT_CHECK_ON;
 113
 114   negative = (m64 & 0x80000000) ? SIGN_Negative : SIGN_Positive;
 115   exp = ((m64 & 0x7ff00000) >> 20) - DOUBLE_Ebias + EXTENDED_Ebias;
 116   m64 &= 0xfffff;
 117   if ( exp > DOUBLE_Emax + EXTENDED_Ebias )
 118     {
 119       /* Infinity or NaN */
 120       if ((m64 == 0) && (l64 == 0))
 121         {
 122           /* +- infinity */
 123           loaded_data->sigh = 0x80000000;
 124           loaded_data->sigl = 0x00000000;
 125           exp = EXP_Infinity + EXTENDED_Ebias;
 126           tag = TAG_Special;
 127         }
 128       else
 129         {
 130           /* Must be a signaling or quiet NaN */
 131           exp = EXP_NaN + EXTENDED_Ebias;
 132           loaded_data->sigh = (m64 << 11) | 0x80000000;
 133           loaded_data->sigh |= l64 >> 21;
 134           loaded_data->sigl = l64 << 11;
 135           tag = TAG_Special;    /* The calling function must look for NaNs */
 136         }
 137     }
 138   else if ( exp < DOUBLE_Emin + EXTENDED_Ebias )
 139     {
 140       /* Zero or de-normal */
 141       if ((m64 == 0) && (l64 == 0))
 142         {
 143           /* Zero */
 144           reg_copy(&CONST_Z, loaded_data);
 145           exp = 0;
 146           tag = TAG_Zero;
 147         }
 148       else
 149         {
 150           /* De-normal */
 151           loaded_data->sigh = m64 << 11;
 152           loaded_data->sigh |= l64 >> 21;
 153           loaded_data->sigl = l64 << 11;
 154
 155           return normalize_no_excep(loaded_data, DOUBLE_Emin, negative)
 156             | (denormal_operand() < 0 ? FPU_Exception : 0);
 157         }
 158     }
 159   else
 160     {
 161       loaded_data->sigh = (m64 << 11) | 0x80000000;
 162       loaded_data->sigh |= l64 >> 21;
 163       loaded_data->sigl = l64 << 11;
 164
 165       tag = TAG_Valid;
 166     }
 167
 168   setexponent16(loaded_data, exp | negative);
 169
 170   return tag;
 171 }
 172
 173
 174 /* Get a float from user memory */
 175 int FPU_load_single(float __user *single, FPU_REG *loaded_data)
 176 {
 177   unsigned m32;
 178   int exp, tag, negative;
 179
 180   RE_ENTRANT_CHECK_OFF;
 181   FPU_access_ok(VERIFY_READ, single, 4);
 182   FPU_get_user(m32, (unsigned long __user *) single);
 183   RE_ENTRANT_CHECK_ON;
 184
 185   negative = (m32 & 0x80000000) ? SIGN_Negative : SIGN_Positive;
 186
 187   if (!(m32 & 0x7fffffff))
 188     {
 189       /* Zero */
 190       reg_copy(&CONST_Z, loaded_data);
 191       addexponent(loaded_data, negative);
 192       return TAG_Zero;
 193     }
 194   exp = ((m32 & 0x7f800000) >> 23) - SINGLE_Ebias + EXTENDED_Ebias;
 195   m32 = (m32 & 0x7fffff) << 8;
 196   if ( exp < SINGLE_Emin + EXTENDED_Ebias )
 197     {
 198       /* De-normals */
 199       loaded_data->sigh = m32;
 200       loaded_data->sigl = 0;
 201
 202       return normalize_no_excep(loaded_data, SINGLE_Emin, negative)
 203         | (denormal_operand() < 0 ? FPU_Exception : 0);
 204     }
 205   else if ( exp > SINGLE_Emax + EXTENDED_Ebias )
 206     {
 207     /* Infinity or NaN */
 208       if ( m32 == 0 )
 209         {
 210           /* +- infinity */
 211           loaded_data->sigh = 0x80000000;
 212           loaded_data->sigl = 0x00000000;
 213           exp = EXP_Infinity + EXTENDED_Ebias;
 214           tag = TAG_Special;
 215         }
 216       else
 217         {
 218           /* Must be a signaling or quiet NaN */
 219           exp = EXP_NaN + EXTENDED_Ebias;
 220           loaded_data->sigh = m32 | 0x80000000;
 221           loaded_data->sigl = 0;
 222           tag = TAG_Special;  /* The calling function must look for NaNs */
 223         }
 224     }
 225   else
 226     {
 227       loaded_data->sigh = m32 | 0x80000000;
 228       loaded_data->sigl = 0;
 229       tag = TAG_Valid;
 230     }
 231
 232   setexponent16(loaded_data, exp | negative);  /* Set the sign. */
 233
 234   return tag;
 235 }
 236
 237
 238 /* Get a long long from user memory */
 239 int FPU_load_int64(long long __user *_s)
 240 {
 241   long long s;
 242   int sign;
 243   FPU_REG *st0_ptr = &st(0);
 244
 245   RE_ENTRANT_CHECK_OFF;
 246   FPU_access_ok(VERIFY_READ, _s, 8);
 247   if (copy_from_user(&s,_s,8))
 248     FPU_abort;
 249   RE_ENTRANT_CHECK_ON;
 250
 251   if (s == 0)
 252     {
 253       reg_copy(&CONST_Z, st0_ptr);
 254       return TAG_Zero;
 255     }
 256
 257   if (s > 0)
 258     sign = SIGN_Positive;
 259   else
 260   {
 261     s = -s;
 262     sign = SIGN_Negative;
 263   }
 264
 265   significand(st0_ptr) = s;
 266
 267   return normalize_no_excep(st0_ptr, 63, sign);
 268 }
 269
 270
 271 /* Get a long from user memory */
 272 int FPU_load_int32(long __user *_s, FPU_REG *loaded_data)
 273 {
 274   long s;
 275   int negative;
 276
 277   RE_ENTRANT_CHECK_OFF;
 278   FPU_access_ok(VERIFY_READ, _s, 4);
 279   FPU_get_user(s, _s);
 280   RE_ENTRANT_CHECK_ON;
 281
 282   if (s == 0)
 283     { reg_copy(&CONST_Z, loaded_data); return TAG_Zero; }
 284
 285   if (s > 0)
 286     negative = SIGN_Positive;
 287   else
 288     {
 289       s = -s;
 290       negative = SIGN_Negative;
 291     }
 292
 293   loaded_data->sigh = s;
 294   loaded_data->sigl = 0;
 295
 296   return normalize_no_excep(loaded_data, 31, negative);
 297 }
 298
 299
 300 /* Get a short from user memory */
 301 int FPU_load_int16(short __user *_s, FPU_REG *loaded_data)
 302 {
 303   int s, negative;
 304
 305   RE_ENTRANT_CHECK_OFF;
 306   FPU_access_ok(VERIFY_READ, _s, 2);
 307   /* Cast as short to get the sign extended. */
 308   FPU_get_user(s, _s);
 309   RE_ENTRANT_CHECK_ON;
 310
 311   if (s == 0)
 312     { reg_copy(&CONST_Z, loaded_data); return TAG_Zero; }
 313
 314   if (s > 0)
 315     negative = SIGN_Positive;
 316   else
 317     {
 318       s = -s;
 319       negative = SIGN_Negative;
 320     }
 321
 322   loaded_data->sigh = s << 16;
 323   loaded_data->sigl = 0;
 324
 325   return normalize_no_excep(loaded_data, 15, negative);
 326 }
 327
 328
 329 /* Get a packed bcd array from user memory */
 330 int FPU_load_bcd(u_char __user *s)
 331 {
 332   FPU_REG *st0_ptr = &st(0);
 333   int pos;
 334   u_char bcd;
 335   long long l=0;
 336   int sign;
 337
 338   RE_ENTRANT_CHECK_OFF;
 339   FPU_access_ok(VERIFY_READ, s, 10);
 340   RE_ENTRANT_CHECK_ON;
 341   for ( pos = 8; pos >= 0; pos--)
 342     {
 343       l *= 10;
 344       RE_ENTRANT_CHECK_OFF;
 345       FPU_get_user(bcd, s+pos);
 346       RE_ENTRANT_CHECK_ON;
 347       l += bcd >> 4;
 348       l *= 10;
 349       l += bcd & 0x0f;
 350     }
 351
 352   RE_ENTRANT_CHECK_OFF;
 353   FPU_get_user(sign, s+9);
 354   sign = sign & 0x80 ? SIGN_Negative : SIGN_Positive;
 355   RE_ENTRANT_CHECK_ON;
 356
 357   if ( l == 0 )
 358     {
 359       reg_copy(&CONST_Z, st0_ptr);
 360       addexponent(st0_ptr, sign);   /* Set the sign. */
 361       return TAG_Zero;
 362     }
 363   else
 364     {
 365       significand(st0_ptr) = l;
 366       return normalize_no_excep(st0_ptr, 63, sign);
 367     }
 368 }
 369
 370 /*===========================================================================*/
 371
 372 /* Put a long double into user memory */
 373 int FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag, long double __user *d)
 374 {
 375   /*
 376     The only exception raised by an attempt to store to an
 377     extended format is the Invalid Stack exception, i.e.
 378     attempting to store from an empty register.
 379    */
 380
 381   if ( st0_tag != TAG_Empty )
 382     {
 383       RE_ENTRANT_CHECK_OFF;
 384       FPU_access_ok(VERIFY_WRITE, d, 10);
 385
 386       FPU_put_user(st0_ptr->sigl, (unsigned long __user *) d);
 387       FPU_put_user(st0_ptr->sigh, (unsigned long __user *) ((u_char __user *)d + 4));
 388       FPU_put_user(exponent16(st0_ptr), (unsigned short __user *) ((u_char __user *)d + 8));
 389       RE_ENTRANT_CHECK_ON;
 390
 391       return 1;
 392     }
 393
 394   /* Empty register (stack underflow) */
 395   EXCEPTION(EX_StackUnder);
 396   if ( control_word & CW_Invalid )
 397     {
 398       /* The masked response */
 399       /* Put out the QNaN indefinite */
 400       RE_ENTRANT_CHECK_OFF;
 401       FPU_access_ok(VERIFY_WRITE,d,10);
 402       FPU_put_user(0, (unsigned long __user *) d);
 403       FPU_put_user(0xc0000000, 1 + (unsigned long __user *) d);
 404       FPU_put_user(0xffff, 4 + (short __user *) d);
 405       RE_ENTRANT_CHECK_ON;
 406       return 1;
 407     }
 408   else
 409     return 0;
 410
 411 }
 412
 413
 414 /* Put a double into user memory */
 415 int FPU_store_double(FPU_REG *st0_ptr, u_char st0_tag, double __user *dfloat)
 416 {
 417   unsigned long l[2];
 418   unsigned long increment = 0;  /* avoid gcc warnings */
 419   int precision_loss;
 420   int exp;
 421   FPU_REG tmp;
 422
 423   if ( st0_tag == TAG_Valid )
 424     {
 425       reg_copy(st0_ptr, &tmp);
 426       exp = exponent(&tmp);
 427
 428       if ( exp < DOUBLE_Emin )     /* It may be a denormal */
 429         {
 430           addexponent(&tmp, -DOUBLE_Emin + 52);  /* largest exp to be 51 */
 431
 432         denormal_arg:
 433
 434           if ( (precision_loss = FPU_round_to_int(&tmp, st0_tag)) )
 435             {
 436 #ifdef PECULIAR_486
 437               /* Did it round to a non-denormal ? */
 438               /* This behaviour might be regarded as peculiar, it appears
 439                  that the 80486 rounds to the dest precision, then
 440                  converts to decide underflow. */
 441               if ( !((tmp.sigh == 0x00100000) && (tmp.sigl == 0) &&
 442                   (st0_ptr->sigl & 0x000007ff)) )
 443 #endif /* PECULIAR_486 */
 444                 {
 445                   EXCEPTION(EX_Underflow);
 446                   /* This is a special case: see sec 16.2.5.1 of
 447                      the 80486 book */
 448                   if ( !(control_word & CW_Underflow) )
 449                     return 0;
 450                 }
 451               EXCEPTION(precision_loss);
 452               if ( !(control_word & CW_Precision) )
 453                 return 0;
 454             }
 455           l[0] = tmp.sigl;
 456           l[1] = tmp.sigh;
 457         }
 458       else
 459         {
 460           if ( tmp.sigl & 0x000007ff )
 461             {
 462               precision_loss = 1;
 463               switch (control_word & CW_RC)
 464                 {
 465                 case RC_RND:
 466                   /* Rounding can get a little messy.. */
 467                   increment = ((tmp.sigl & 0x7ff) > 0x400) |  /* nearest */
 468                     ((tmp.sigl & 0xc00) == 0xc00);            /* odd -> even */
 469                   break;
 470                 case RC_DOWN:   /* towards -infinity */
 471                   increment = signpositive(&tmp) ? 0 : tmp.sigl & 0x7ff;
 472                   break;
 473                 case RC_UP:     /* towards +infinity */
 474                   increment = signpositive(&tmp) ? tmp.sigl & 0x7ff : 0;
 475                   break;
 476                 case RC_CHOP:
 477                   increment = 0;
 478                   break;
 479                 }
 480
 481               /* Truncate the mantissa */
 482               tmp.sigl &= 0xfffff800;
 483
 484               if ( increment )
 485                 {
 486                   if ( tmp.sigl >= 0xfffff800 )
 487                     {
 488                       /* the sigl part overflows */
 489                       if ( tmp.sigh == 0xffffffff )
 490                         {
 491                           /* The sigh part overflows */
 492                           tmp.sigh = 0x80000000;
 493                           exp++;
 494                           if (exp >= EXP_OVER)
 495                             goto overflow;
 496                         }
 497                       else
 498                         {
 499                           tmp.sigh ++;
 500                         }
 501                       tmp.sigl = 0x00000000;
 502                     }
 503                   else
 504                     {
 505                       /* We only need to increment sigl */
 506                       tmp.sigl += 0x00000800;
 507                     }
 508                 }
 509             }
 510           else
 511             precision_loss = 0;
 512
 513           l[0] = (tmp.sigl >> 11) | (tmp.sigh << 21);
 514           l[1] = ((tmp.sigh >> 11) & 0xfffff);
 515
 516           if ( exp > DOUBLE_Emax )
 517             {
 518             overflow:
 519               EXCEPTION(EX_Overflow);
 520               if ( !(control_word & CW_Overflow) )
 521                 return 0;
 522               set_precision_flag_up();
 523               if ( !(control_word & CW_Precision) )
 524                 return 0;
 525
 526               /* This is a special case: see sec 16.2.5.1 of the 80486 book */
 527               /* Overflow to infinity */
 528               l[0] = 0x00000000;        /* Set to */
 529               l[1] = 0x7ff00000;        /* + INF */
 530             }
 531           else
 532             {
 533               if ( precision_loss )
 534                 {
 535                   if ( increment )
 536                     set_precision_flag_up();
 537                   else
 538                     set_precision_flag_down();
 539                 }
 540               /* Add the exponent */
 541               l[1] |= (((exp+DOUBLE_Ebias) & 0x7ff) << 20);
 542             }
 543         }
 544     }
 545   else if (st0_tag == TAG_Zero)
 546     {
 547       /* Number is zero */
 548       l[0] = 0;
 549       l[1] = 0;
 550     }
 551   else if ( st0_tag == TAG_Special )
 552     {
 553       st0_tag = FPU_Special(st0_ptr);
 554       if ( st0_tag == TW_Denormal )
 555         {
 556           /* A denormal will always underflow. */
 557 #ifndef PECULIAR_486
 558           /* An 80486 is supposed to be able to generate
 559              a denormal exception here, but... */
 560           /* Underflow has priority. */
 561           if ( control_word & CW_Underflow )
 562             denormal_operand();
 563 #endif /* PECULIAR_486 */
 564           reg_copy(st0_ptr, &tmp);
 565           goto denormal_arg;
 566         }
 567       else if (st0_tag == TW_Infinity)
 568         {
 569           l[0] = 0;
 570           l[1] = 0x7ff00000;
 571         }
 572       else if (st0_tag == TW_NaN)
 573         {
 574           /* Is it really a NaN ? */
 575           if ( (exponent(st0_ptr) == EXP_OVER)
 576                && (st0_ptr->sigh & 0x80000000) )
 577             {
 578               /* See if we can get a valid NaN from the FPU_REG */
 579               l[0] = (st0_ptr->sigl >> 11) | (st0_ptr->sigh << 21);
 580               l[1] = ((st0_ptr->sigh >> 11) & 0xfffff);
 581               if ( !(st0_ptr->sigh & 0x40000000) )
 582                 {
 583                   /* It is a signalling NaN */
 584                   EXCEPTION(EX_Invalid);
 585                   if ( !(control_word & CW_Invalid) )
 586                     return 0;
 587                   l[1] |= (0x40000000 >> 11);
 588                 }
 589               l[1] |= 0x7ff00000;
 590             }
 591           else
 592             {
 593               /* It is an unsupported data type */
 594               EXCEPTION(EX_Invalid);
 595               if ( !(control_word & CW_Invalid) )
 596                 return 0;
 597               l[0] = 0;
 598               l[1] = 0xfff80000;
 599             }
 600         }
 601     }
 602   else if ( st0_tag == TAG_Empty )
 603     {
 604       /* Empty register (stack underflow) */
 605       EXCEPTION(EX_StackUnder);
 606       if ( control_word & CW_Invalid )
 607         {
 608           /* The masked response */
 609           /* Put out the QNaN indefinite */
 610           RE_ENTRANT_CHECK_OFF;
 611           FPU_access_ok(VERIFY_WRITE,dfloat,8);
 612           FPU_put_user(0, (unsigned long __user *) dfloat);
 613           FPU_put_user(0xfff80000, 1 + (unsigned long __user *) dfloat);
 614           RE_ENTRANT_CHECK_ON;
 615           return 1;
 616         }
 617       else
 618         return 0;
 619     }
 620   if ( getsign(st0_ptr) )
 621     l[1] |= 0x80000000;
 622
 623   RE_ENTRANT_CHECK_OFF;
 624   FPU_access_ok(VERIFY_WRITE,dfloat,8);
 625   FPU_put_user(l[0], (unsigned long __user *)dfloat);
 626   FPU_put_user(l[1], 1 + (unsigned long __user *)dfloat);
 627   RE_ENTRANT_CHECK_ON;
 628
 629   return 1;
 630 }
 631
 632
 633 /* Put a float into user memory */
 634 int FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag, float __user *single)
 635 {
 636   long templ = 0;
 637   unsigned long increment = 0;          /* avoid gcc warnings */
 638   int precision_loss;
 639   int exp;
 640   FPU_REG tmp;
 641
 642   if ( st0_tag == TAG_Valid )
 643     {
 644
 645       reg_copy(st0_ptr, &tmp);
 646       exp = exponent(&tmp);
 647
 648       if ( exp < SINGLE_Emin )
 649         {
 650           addexponent(&tmp, -SINGLE_Emin + 23);  /* largest exp to be 22 */
 651
 652         denormal_arg:
 653
 654           if ( (precision_loss = FPU_round_to_int(&tmp, st0_tag)) )
 655             {
 656 #ifdef PECULIAR_486
 657               /* Did it round to a non-denormal ? */
 658               /* This behaviour might be regarded as peculiar, it appears
 659                  that the 80486 rounds to the dest precision, then
 660                  converts to decide underflow. */
 661               if ( !((tmp.sigl == 0x00800000) &&
 662                   ((st0_ptr->sigh & 0x000000ff) || st0_ptr->sigl)) )
 663 #endif /* PECULIAR_486 */
 664                 {
 665                   EXCEPTION(EX_Underflow);
 666                   /* This is a special case: see sec 16.2.5.1 of
 667                      the 80486 book */
 668                   if ( !(control_word & CW_Underflow) )
 669                     return 0;
 670                 }
 671               EXCEPTION(precision_loss);
 672               if ( !(control_word & CW_Precision) )
 673                 return 0;
 674             }
 675           templ = tmp.sigl;
 676       }
 677       else
 678         {
 679           if ( tmp.sigl | (tmp.sigh & 0x000000ff) )
 680             {
 681               unsigned long sigh = tmp.sigh;
 682               unsigned long sigl = tmp.sigl;
 683
 684               precision_loss = 1;
 685               switch (control_word & CW_RC)
 686                 {
 687                 case RC_RND:
 688                   increment = ((sigh & 0xff) > 0x80)       /* more than half */
 689                     || (((sigh & 0xff) == 0x80) && sigl)   /* more than half */
 690                     || ((sigh & 0x180) == 0x180);        /* round to even */
 691                   break;
 692                 case RC_DOWN:   /* towards -infinity */
 693                   increment = signpositive(&tmp)
 694                     ? 0 : (sigl | (sigh & 0xff));
 695                   break;
 696                 case RC_UP:     /* towards +infinity */
 697                   increment = signpositive(&tmp)
 698                     ? (sigl | (sigh & 0xff)) : 0;
 699                   break;
 700                 case RC_CHOP:
 701                   increment = 0;
 702                   break;
 703                 }
 704
 705               /* Truncate part of the mantissa */
 706               tmp.sigl = 0;
 707
 708               if (increment)
 709                 {
 710                   if ( sigh >= 0xffffff00 )
 711                     {
 712                       /* The sigh part overflows */
 713                       tmp.sigh = 0x80000000;
 714                       exp++;
 715                       if ( exp >= EXP_OVER )
 716                         goto overflow;
 717                     }
 718                   else
 719                     {
 720                       tmp.sigh &= 0xffffff00;
 721                       tmp.sigh += 0x100;
 722                     }
 723                 }
 724               else
 725                 {
 726                   tmp.sigh &= 0xffffff00;  /* Finish the truncation */
 727                 }
 728             }
 729           else
 730             precision_loss = 0;
 731
 732           templ = (tmp.sigh >> 8) & 0x007fffff;
 733
 734           if ( exp > SINGLE_Emax )
 735             {
 736             overflow:
 737               EXCEPTION(EX_Overflow);
 738               if ( !(control_word & CW_Overflow) )
 739                 return 0;
 740               set_precision_flag_up();
 741               if ( !(control_word & CW_Precision) )
 742                 return 0;
 743
 744               /* This is a special case: see sec 16.2.5.1 of the 80486 book. */
 745               /* Masked response is overflow to infinity. */
 746               templ = 0x7f800000;
 747             }
 748           else
 749             {
 750               if ( precision_loss )
 751                 {
 752                   if ( increment )
 753                     set_precision_flag_up();
 754                   else
 755                     set_precision_flag_down();
 756                 }
 757               /* Add the exponent */
 758               templ |= ((exp+SINGLE_Ebias) & 0xff) << 23;
 759             }
 760         }
 761     }
 762   else if (st0_tag == TAG_Zero)
 763     {
 764       templ = 0;
 765     }
 766   else if ( st0_tag == TAG_Special )
 767     {
 768       st0_tag = FPU_Special(st0_ptr);
 769       if (st0_tag == TW_Denormal)
 770         {
 771           reg_copy(st0_ptr, &tmp);
 772
 773           /* A denormal will always underflow. */
 774 #ifndef PECULIAR_486
 775           /* An 80486 is supposed to be able to generate
 776              a denormal exception here, but... */
 777           /* Underflow has priority. */
 778           if ( control_word & CW_Underflow )
 779             denormal_operand();
 780 #endif /* PECULIAR_486 */
 781           goto denormal_arg;
 782         }
 783       else if (st0_tag == TW_Infinity)
 784         {
 785           templ = 0x7f800000;
 786         }
 787       else if (st0_tag == TW_NaN)
 788         {
 789           /* Is it really a NaN ? */
 790           if ( (exponent(st0_ptr) == EXP_OVER) && (st0_ptr->sigh & 0x80000000) )
 791             {
 792               /* See if we can get a valid NaN from the FPU_REG */
 793               templ = st0_ptr->sigh >> 8;
 794               if ( !(st0_ptr->sigh & 0x40000000) )
 795                 {
 796                   /* It is a signalling NaN */
 797                   EXCEPTION(EX_Invalid);
 798                   if ( !(control_word & CW_Invalid) )
 799                     return 0;
 800                   templ |= (0x40000000 >> 8);
 801                 }
 802               templ |= 0x7f800000;
 803             }
 804           else
 805             {
 806               /* It is an unsupported data type */
 807               EXCEPTION(EX_Invalid);
 808               if ( !(control_word & CW_Invalid) )
 809                 return 0;
 810               templ = 0xffc00000;
 811             }
 812         }
 813 #ifdef PARANOID
 814       else
 815         {
 816           EXCEPTION(EX_INTERNAL|0x164);
 817           return 0;
 818         }
 819 #endif
 820     }
 821   else if ( st0_tag == TAG_Empty )
 822     {
 823       /* Empty register (stack underflow) */
 824       EXCEPTION(EX_StackUnder);
 825       if ( control_word & EX_Invalid )
 826         {
 827           /* The masked response */
 828           /* Put out the QNaN indefinite */
 829           RE_ENTRANT_CHECK_OFF;
 830           FPU_access_ok(VERIFY_WRITE,single,4);
 831           FPU_put_user(0xffc00000, (unsigned long __user *) single);
 832           RE_ENTRANT_CHECK_ON;
 833           return 1;
 834         }
 835       else
 836         return 0;
 837     }
 838 #ifdef PARANOID
 839   else
 840     {
 841       EXCEPTION(EX_INTERNAL|0x163);
 842       return 0;
 843     }
 844 #endif
 845   if ( getsign(st0_ptr) )
 846     templ |= 0x80000000;
 847
 848   RE_ENTRANT_CHECK_OFF;
 849   FPU_access_ok(VERIFY_WRITE,single,4);
 850   FPU_put_user(templ,(unsigned long __user *) single);
 851   RE_ENTRANT_CHECK_ON;
 852
 853   return 1;
 854 }
 855
 856
 857 /* Put a long long into user memory */
 858 int FPU_store_int64(FPU_REG *st0_ptr, u_char st0_tag, long long __user *d)
 859 {
 860   FPU_REG t;
 861   long long tll;
 862   int precision_loss;
 863
 864   if ( st0_tag == TAG_Empty )
 865     {
 866       /* Empty register (stack underflow) */
 867       EXCEPTION(EX_StackUnder);
 868       goto invalid_operand;
 869     }
 870   else if ( st0_tag == TAG_Special )
 871     {
 872       st0_tag = FPU_Special(st0_ptr);
 873       if ( (st0_tag == TW_Infinity) ||
 874            (st0_tag == TW_NaN) )
 875         {
 876           EXCEPTION(EX_Invalid);
 877           goto invalid_operand;
 878         }
 879     }
 880
 881   reg_copy(st0_ptr, &t);
 882   precision_loss = FPU_round_to_int(&t, st0_tag);
 883   ((long *)&tll)[0] = t.sigl;
 884   ((long *)&tll)[1] = t.sigh;
 885   if ( (precision_loss == 1) ||
 886       ((t.sigh & 0x80000000) &&
 887        !((t.sigh == 0x80000000) && (t.sigl == 0) &&
 888          signnegative(&t))) )
 889     {
 890       EXCEPTION(EX_Invalid);
 891       /* This is a special case: see sec 16.2.5.1 of the 80486 book */
 892     invalid_operand:
 893       if ( control_word & EX_Invalid )
 894         {
 895           /* Produce something like QNaN "indefinite" */
 896           tll = 0x8000000000000000LL;
 897         }
 898       else
 899         return 0;
 900     }
 901   else
 902     {
 903       if ( precision_loss )
 904         set_precision_flag(precision_loss);
 905       if ( signnegative(&t) )
 906         tll = - tll;
 907     }
 908
 909   RE_ENTRANT_CHECK_OFF;
 910   FPU_access_ok(VERIFY_WRITE,d,8);
 911   if (copy_to_user(d, &tll, 8))
 912     FPU_abort;
 913   RE_ENTRANT_CHECK_ON;
 914
 915   return 1;
 916 }
 917
 918
 919 /* Put a long into user memory */
 920 int FPU_store_int32(FPU_REG *st0_ptr, u_char st0_tag, long __user *d)
 921 {
 922   FPU_REG t;
 923   int precision_loss;
 924
 925   if ( st0_tag == TAG_Empty )
 926     {
 927       /* Empty register (stack underflow) */
 928       EXCEPTION(EX_StackUnder);
 929       goto invalid_operand;
 930     }
 931   else if ( st0_tag == TAG_Special )
 932     {
 933       st0_tag = FPU_Special(st0_ptr);
 934       if ( (st0_tag == TW_Infinity) ||
 935            (st0_tag == TW_NaN) )
 936         {
 937           EXCEPTION(EX_Invalid);
 938           goto invalid_operand;
 939         }
 940     }
 941
 942   reg_copy(st0_ptr, &t);
 943   precision_loss = FPU_round_to_int(&t, st0_tag);
 944   if (t.sigh ||
 945       ((t.sigl & 0x80000000) &&
 946        !((t.sigl == 0x80000000) && signnegative(&t))) )
 947     {
 948       EXCEPTION(EX_Invalid);
 949       /* This is a special case: see sec 16.2.5.1 of the 80486 book */
 950     invalid_operand:
 951       if ( control_word & EX_Invalid )
 952         {
 953           /* Produce something like QNaN "indefinite" */
 954           t.sigl = 0x80000000;
 955         }
 956       else
 957         return 0;
 958     }
 959   else
 960     {
 961       if ( precision_loss )
 962         set_precision_flag(precision_loss);
 963       if ( signnegative(&t) )
 964         t.sigl = -(long)t.sigl;
 965     }
 966
 967   RE_ENTRANT_CHECK_OFF;
 968   FPU_access_ok(VERIFY_WRITE,d,4);
 969   FPU_put_user(t.sigl, (unsigned long __user *) d);
 970   RE_ENTRANT_CHECK_ON;
 971
 972   return 1;
 973 }
 974
 975
 976 /* Put a short into user memory */
 977 int FPU_store_int16(FPU_REG *st0_ptr, u_char st0_tag, short __user *d)
 978 {
 979   FPU_REG t;
 980   int precision_loss;
 981
 982   if ( st0_tag == TAG_Empty )
 983     {
 984       /* Empty register (stack underflow) */
 985       EXCEPTION(EX_StackUnder);
 986       goto invalid_operand;
 987     }
 988   else if ( st0_tag == TAG_Special )
 989     {
 990       st0_tag = FPU_Special(st0_ptr);
 991       if ( (st0_tag == TW_Infinity) ||
 992            (st0_tag == TW_NaN) )
 993         {
 994           EXCEPTION(EX_Invalid);
 995           goto invalid_operand;
 996         }
 997     }
 998
 999   reg_copy(st0_ptr, &t);
1000   precision_loss = FPU_round_to_int(&t, st0_tag);
1001   if (t.sigh ||
1002       ((t.sigl & 0xffff8000) &&
1003        !((t.sigl == 0x8000) && signnegative(&t))) )
1004     {
1005       EXCEPTION(EX_Invalid);
1006       /* This is a special case: see sec 16.2.5.1 of the 80486 book */
1007     invalid_operand:
1008       if ( control_word & EX_Invalid )
1009         {
1010           /* Produce something like QNaN "indefinite" */
1011           t.sigl = 0x8000;
1012         }
1013       else
1014         return 0;
1015     }
1016   else
1017     {
1018       if ( precision_loss )
1019         set_precision_flag(precision_loss);
1020       if ( signnegative(&t) )
1021         t.sigl = -t.sigl;
1022     }
1023
1024   RE_ENTRANT_CHECK_OFF;
1025   FPU_access_ok(VERIFY_WRITE,d,2);
1026   FPU_put_user((short)t.sigl, d);
1027   RE_ENTRANT_CHECK_ON;
1028
1029   return 1;
1030 }
1031
1032
1033 /* Put a packed bcd array into user memory */
1034 int FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char __user *d)
1035 {
1036   FPU_REG t;
1037   unsigned long long ll;
1038   u_char b;
1039   int i, precision_loss;
1040   u_char sign = (getsign(st0_ptr) == SIGN_NEG) ? 0x80 : 0;
1041
1042   if ( st0_tag == TAG_Empty )
1043     {
1044       /* Empty register (stack underflow) */
1045       EXCEPTION(EX_StackUnder);
1046       goto invalid_operand;
1047     }
1048   else if ( st0_tag == TAG_Special )
1049     {
1050       st0_tag = FPU_Special(st0_ptr);
1051       if ( (st0_tag == TW_Infinity) ||
1052            (st0_tag == TW_NaN) )
1053         {
1054           EXCEPTION(EX_Invalid);
1055           goto invalid_operand;
1056         }
1057     }
1058
1059   reg_copy(st0_ptr, &t);
1060   precision_loss = FPU_round_to_int(&t, st0_tag);
1061   ll = significand(&t);
1062
1063   /* Check for overflow, by comparing with 999999999999999999 decimal. */
1064   if ( (t.sigh > 0x0de0b6b3) ||
1065       ((t.sigh == 0x0de0b6b3) && (t.sigl > 0xa763ffff)) )
1066     {
1067       EXCEPTION(EX_Invalid);
1068       /* This is a special case: see sec 16.2.5.1 of the 80486 book */
1069     invalid_operand:
1070       if ( control_word & CW_Invalid )
1071         {
1072           /* Produce the QNaN "indefinite" */
1073           RE_ENTRANT_CHECK_OFF;
1074           FPU_access_ok(VERIFY_WRITE,d,10);
1075           for ( i = 0; i < 7; i++)
1076             FPU_put_user(0, d+i); /* These bytes "undefined" */
1077           FPU_put_user(0xc0, d+7); /* This byte "undefined" */
1078           FPU_put_user(0xff, d+8);
1079           FPU_put_user(0xff, d+9);
1080           RE_ENTRANT_CHECK_ON;
1081           return 1;
1082         }
1083       else
1084         return 0;
1085     }
1086   else if ( precision_loss )
1087     {
1088       /* Precision loss doesn't stop the data transfer */
1089       set_precision_flag(precision_loss);
1090     }
1091
1092   RE_ENTRANT_CHECK_OFF;
1093   FPU_access_ok(VERIFY_WRITE,d,10);
1094   RE_ENTRANT_CHECK_ON;
1095   for ( i = 0; i < 9; i++)
1096     {
1097       b = FPU_div_small(&ll, 10);
1098       b |= (FPU_div_small(&ll, 10)) << 4;
1099       RE_ENTRANT_CHECK_OFF;
1100       FPU_put_user(b, d+i);
1101       RE_ENTRANT_CHECK_ON;
1102     }
1103   RE_ENTRANT_CHECK_OFF;
1104   FPU_put_user(sign, d+9);
1105   RE_ENTRANT_CHECK_ON;
1106
1107   return 1;
1108 }
1109
1110 /*===========================================================================*/
1111
1112 /* r gets mangled such that sig is int, sign:
1113    it is NOT normalized */
1114 /* The return value (in eax) is zero if the result is exact,
1115    if bits are changed due to rounding, truncation, etc, then
1116    a non-zero value is returned */
1117 /* Overflow is signalled by a non-zero return value (in eax).
1118    In the case of overflow, the returned significand always has the
1119    largest possible value */
1120 int FPU_round_to_int(FPU_REG *r, u_char tag)
1121 {
1122   u_char     very_big;
1123   unsigned eax;
1124
1125   if (tag == TAG_Zero)
1126     {
1127       /* Make sure that zero is returned */
1128       significand(r) = 0;
1129       return 0;        /* o.k. */
1130     }
1131
1132   if (exponent(r) > 63)
1133     {
1134       r->sigl = r->sigh = ~0;      /* The largest representable number */
1135       return 1;        /* overflow */
1136     }
1137
1138   eax = FPU_shrxs(&r->sigl, 63 - exponent(r));
1139   very_big = !(~(r->sigh) | ~(r->sigl));  /* test for 0xfff...fff */
1140 #define half_or_more    (eax & 0x80000000)
1141 #define frac_part       (eax)
1142 #define more_than_half  ((eax & 0x80000001) == 0x80000001)
1143   switch (control_word & CW_RC)
1144     {
1145     case RC_RND:
1146       if ( more_than_half                       /* nearest */
1147           || (half_or_more && (r->sigl & 1)) )  /* odd -> even */
1148         {
1149           if ( very_big ) return 1;        /* overflow */
1150           significand(r) ++;
1151           return PRECISION_LOST_UP;
1152         }
1153       break;
1154     case RC_DOWN:
1155       if (frac_part && getsign(r))
1156         {
1157           if ( very_big ) return 1;        /* overflow */
1158           significand(r) ++;
1159           return PRECISION_LOST_UP;
1160         }
1161       break;
1162     case RC_UP:
1163       if (frac_part && !getsign(r))
1164         {
1165           if ( very_big ) return 1;        /* overflow */
1166           significand(r) ++;
1167           return PRECISION_LOST_UP;
1168         }
1169       break;
1170     case RC_CHOP:
1171       break;
1172     }
1173
1174   return eax ? PRECISION_LOST_DOWN : 0;
1175
1176 }
1177
1178 /*===========================================================================*/
1179
1180 u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user *s)
1181 {
1182   unsigned short tag_word = 0;
1183   u_char tag;
1184   int i;
1185
1186   if ( (addr_modes.default_mode == VM86) ||
1187       ((addr_modes.default_mode == PM16)
1188       ^ (addr_modes.override.operand_size == OP_SIZE_PREFIX)) )
1189     {
1190       RE_ENTRANT_CHECK_OFF;
1191       FPU_access_ok(VERIFY_READ, s, 0x0e);
1192       FPU_get_user(control_word, (unsigned short __user *) s);
1193       FPU_get_user(partial_status, (unsigned short __user *) (s+2));
1194       FPU_get_user(tag_word, (unsigned short __user *) (s+4));
1195       FPU_get_user(instruction_address.offset, (unsigned short __user *) (s+6));
1196       FPU_get_user(instruction_address.selector, (unsigned short __user *) (s+8));
1197       FPU_get_user(operand_address.offset, (unsigned short __user *) (s+0x0a));
1198       FPU_get_user(operand_address.selector, (unsigned short __user *) (s+0x0c));
1199       RE_ENTRANT_CHECK_ON;
1200       s += 0x0e;
1201       if ( addr_modes.default_mode == VM86 )
1202         {
1203           instruction_address.offset
1204             += (instruction_address.selector & 0xf000) << 4;
1205           operand_address.offset += (operand_address.selector & 0xf000) << 4;
1206         }
1207     }
1208   else
1209     {
1210       RE_ENTRANT_CHECK_OFF;
1211       FPU_access_ok(VERIFY_READ, s, 0x1c);
1212       FPU_get_user(control_word, (unsigned short __user *) s);
1213       FPU_get_user(partial_status, (unsigned short __user *) (s+4));
1214       FPU_get_user(tag_word, (unsigned short __user *) (s+8));
1215       FPU_get_user(instruction_address.offset, (unsigned long __user *) (s+0x0c));
1216       FPU_get_user(instruction_address.selector, (unsigned short __user *) (s+0x10));
1217       FPU_get_user(instruction_address.opcode, (unsigned short __user *) (s+0x12));
1218       FPU_get_user(operand_address.offset, (unsigned long __user *) (s+0x14));
1219       FPU_get_user(operand_address.selector, (unsigned long __user *) (s+0x18));
1220       RE_ENTRANT_CHECK_ON;
1221       s += 0x1c;
1222     }
1223
1224 #ifdef PECULIAR_486
1225   control_word &= ~0xe080;
1226 #endif /* PECULIAR_486 */
1227
1228   top = (partial_status >> SW_Top_Shift) & 7;
1229
1230   if ( partial_status & ~control_word & CW_Exceptions )
1231     partial_status |= (SW_Summary | SW_Backward);
1232   else
1233     partial_status &= ~(SW_Summary | SW_Backward);
1234
1235   for ( i = 0; i < 8; i++ )
1236     {
1237       tag = tag_word & 3;
1238       tag_word >>= 2;
1239
1240       if ( tag == TAG_Empty )
1241         /* New tag is empty.  Accept it */
1242         FPU_settag(i, TAG_Empty);
1243       else if ( FPU_gettag(i) == TAG_Empty )
1244         {
1245           /* Old tag is empty and new tag is not empty.  New tag is determined
1246              by old reg contents */
1247           if ( exponent(&fpu_register(i)) == - EXTENDED_Ebias )
1248             {
1249               if ( !(fpu_register(i).sigl | fpu_register(i).sigh) )
1250                 FPU_settag(i, TAG_Zero);
1251               else
1252                 FPU_settag(i, TAG_Special);
1253             }
1254           else if ( exponent(&fpu_register(i)) == 0x7fff - EXTENDED_Ebias )
1255             {
1256               FPU_settag(i, TAG_Special);
1257             }
1258           else if ( fpu_register(i).sigh & 0x80000000 )
1259             FPU_settag(i, TAG_Valid);
1260           else
1261             FPU_settag(i, TAG_Special);   /* An Un-normal */
1262         }
1263       /* Else old tag is not empty and new tag is not empty.  Old tag
1264          remains correct */
1265     }
1266
1267   return s;
1268 }
1269
1270
1271 void frstor(fpu_addr_modes addr_modes, u_char __user *data_address)
1272 {
1273   int i, regnr;
1274   u_char __user *s = fldenv(addr_modes, data_address);
1275   int offset = (top & 7) * 10, other = 80 - offset;
1276
1277   /* Copy all registers in stack order. */
1278   RE_ENTRANT_CHECK_OFF;
1279   FPU_access_ok(VERIFY_READ,s,80);
1280   __copy_from_user(register_base+offset, s, other);
1281   if ( offset )
1282     __copy_from_user(register_base, s+other, offset);
1283   RE_ENTRANT_CHECK_ON;
1284
1285   for ( i = 0; i < 8; i++ )
1286     {
1287       regnr = (i+top) & 7;
1288       if ( FPU_gettag(regnr) != TAG_Empty )
1289         /* The loaded data over-rides all other cases. */
1290         FPU_settag(regnr, FPU_tagof(&st(i)));
1291     }
1292
1293 }
1294
1295
1296 u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user *d)
1297 {
1298   if ( (addr_modes.default_mode == VM86) ||
1299       ((addr_modes.default_mode == PM16)
1300       ^ (addr_modes.override.operand_size == OP_SIZE_PREFIX)) )
1301     {
1302       RE_ENTRANT_CHECK_OFF;
1303       FPU_access_ok(VERIFY_WRITE,d,14);
1304 #ifdef PECULIAR_486
1305       FPU_put_user(control_word & ~0xe080, (unsigned long __user *) d);
1306 #else
1307       FPU_put_user(control_word, (unsigned short __user *) d);
1308 #endif /* PECULIAR_486 */
1309       FPU_put_user(status_word(), (unsigned short __user *) (d+2));
1310       FPU_put_user(fpu_tag_word, (unsigned short __user *) (d+4));
1311       FPU_put_user(instruction_address.offset, (unsigned short __user *) (d+6));
1312       FPU_put_user(operand_address.offset, (unsigned short __user *) (d+0x0a));
1313       if ( addr_modes.default_mode == VM86 )
1314         {
1315           FPU_put_user((instruction_address.offset & 0xf0000) >> 4,
1316                       (unsigned short __user *) (d+8));
1317           FPU_put_user((operand_address.offset & 0xf0000) >> 4,
1318                       (unsigned short __user *) (d+0x0c));
1319         }
1320       else
1321         {
1322           FPU_put_user(instruction_address.selector, (unsigned short __user *) (d+8));
1323           FPU_put_user(operand_address.selector, (unsigned short __user *) (d+0x0c));
1324         }
1325       RE_ENTRANT_CHECK_ON;
1326       d += 0x0e;
1327     }
1328   else
1329     {
1330       RE_ENTRANT_CHECK_OFF;
1331       FPU_access_ok(VERIFY_WRITE, d, 7*4);
1332 #ifdef PECULIAR_486
1333       control_word &= ~0xe080;
1334       /* An 80486 sets nearly all of the reserved bits to 1. */
1335       control_word |= 0xffff0040;
1336       partial_status = status_word() | 0xffff0000;
1337       fpu_tag_word |= 0xffff0000;
1338       I387.soft.fcs &= ~0xf8000000;
1339       I387.soft.fos |= 0xffff0000;
1340 #endif /* PECULIAR_486 */
1341       if (__copy_to_user(d, &control_word, 7*4))
1342         FPU_abort;
1343       RE_ENTRANT_CHECK_ON;
1344       d += 0x1c;
1345     }
1346
1347   control_word |= CW_Exceptions;
1348   partial_status &= ~(SW_Summary | SW_Backward);
1349
1350   return d;
1351 }
1352
1353
1354 void fsave(fpu_addr_modes addr_modes, u_char __user *data_address)
1355 {
1356   u_char __user *d;
1357   int offset = (top & 7) * 10, other = 80 - offset;
1358
1359   d = fstenv(addr_modes, data_address);
1360
1361   RE_ENTRANT_CHECK_OFF;
1362   FPU_access_ok(VERIFY_WRITE,d,80);
1363
1364   /* Copy all registers in stack order. */
1365   if (__copy_to_user(d, register_base+offset, other))
1366     FPU_abort;
1367   if ( offset )
1368     if (__copy_to_user(d+other, register_base, offset))
1369       FPU_abort;
1370   RE_ENTRANT_CHECK_ON;
1371
1372   finit();
1373 }
1374
1375 /*===========================================================================*/