target/mips/lmi_helper.c

   1 /*
   2  *  Loongson Multimedia Instruction emulation helpers for QEMU.
   3  *
   4  *  Copyright (c) 2011  Richard Henderson <rth@twiddle.net>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "cpu.h"
  22 #include "exec/helper-proto.h"
  23
  24 /*
  25  * If the byte ordering doesn't matter, i.e. all columns are treated
  26  * identically, then this union can be used directly.  If byte ordering
  27  * does matter, we generally ignore dumping to memory.
  28  */
  29 typedef union {
  30     uint8_t  ub[8];
  31     int8_t   sb[8];
  32     uint16_t uh[4];
  33     int16_t  sh[4];
  34     uint32_t uw[2];
  35     int32_t  sw[2];
  36     uint64_t d;
  37 } LMIValue;
  38
  39 /* Some byte ordering issues can be mitigated by XORing in the following.  */
  40 #ifdef HOST_WORDS_BIGENDIAN
  41 # define BYTE_ORDER_XOR(N) N
  42 #else
  43 # define BYTE_ORDER_XOR(N) 0
  44 #endif
  45
  46 #define SATSB(x)  (x < -0x80 ? -0x80 : x > 0x7f ? 0x7f : x)
  47 #define SATUB(x)  (x > 0xff ? 0xff : x)
  48
  49 #define SATSH(x)  (x < -0x8000 ? -0x8000 : x > 0x7fff ? 0x7fff : x)
  50 #define SATUH(x)  (x > 0xffff ? 0xffff : x)
  51
  52 #define SATSW(x) \
  53     (x < -0x80000000ll ? -0x80000000ll : x > 0x7fffffff ? 0x7fffffff : x)
  54 #define SATUW(x)  (x > 0xffffffffull ? 0xffffffffull : x)
  55
  56 uint64_t helper_paddsb(uint64_t fs, uint64_t ft)
  57 {
  58     LMIValue vs, vt;
  59     unsigned int i;
  60
  61     vs.d = fs;
  62     vt.d = ft;
  63     for (i = 0; i < 8; ++i) {
  64         int r = vs.sb[i] + vt.sb[i];
  65         vs.sb[i] = SATSB(r);
  66     }
  67     return vs.d;
  68 }
  69
  70 uint64_t helper_paddusb(uint64_t fs, uint64_t ft)
  71 {
  72     LMIValue vs, vt;
  73     unsigned int i;
  74
  75     vs.d = fs;
  76     vt.d = ft;
  77     for (i = 0; i < 8; ++i) {
  78         int r = vs.ub[i] + vt.ub[i];
  79         vs.ub[i] = SATUB(r);
  80     }
  81     return vs.d;
  82 }
  83
  84 uint64_t helper_paddsh(uint64_t fs, uint64_t ft)
  85 {
  86     LMIValue vs, vt;
  87     unsigned int i;
  88
  89     vs.d = fs;
  90     vt.d = ft;
  91     for (i = 0; i < 4; ++i) {
  92         int r = vs.sh[i] + vt.sh[i];
  93         vs.sh[i] = SATSH(r);
  94     }
  95     return vs.d;
  96 }
  97
  98 uint64_t helper_paddush(uint64_t fs, uint64_t ft)
  99 {
 100     LMIValue vs, vt;
 101     unsigned int i;
 102
 103     vs.d = fs;
 104     vt.d = ft;
 105     for (i = 0; i < 4; ++i) {
 106         int r = vs.uh[i] + vt.uh[i];
 107         vs.uh[i] = SATUH(r);
 108     }
 109     return vs.d;
 110 }
 111
 112 uint64_t helper_paddb(uint64_t fs, uint64_t ft)
 113 {
 114     LMIValue vs, vt;
 115     unsigned int i;
 116
 117     vs.d = fs;
 118     vt.d = ft;
 119     for (i = 0; i < 8; ++i) {
 120         vs.ub[i] += vt.ub[i];
 121     }
 122     return vs.d;
 123 }
 124
 125 uint64_t helper_paddh(uint64_t fs, uint64_t ft)
 126 {
 127     LMIValue vs, vt;
 128     unsigned int i;
 129
 130     vs.d = fs;
 131     vt.d = ft;
 132     for (i = 0; i < 4; ++i) {
 133         vs.uh[i] += vt.uh[i];
 134     }
 135     return vs.d;
 136 }
 137
 138 uint64_t helper_paddw(uint64_t fs, uint64_t ft)
 139 {
 140     LMIValue vs, vt;
 141     unsigned int i;
 142
 143     vs.d = fs;
 144     vt.d = ft;
 145     for (i = 0; i < 2; ++i) {
 146         vs.uw[i] += vt.uw[i];
 147     }
 148     return vs.d;
 149 }
 150
 151 uint64_t helper_psubsb(uint64_t fs, uint64_t ft)
 152 {
 153     LMIValue vs, vt;
 154     unsigned int i;
 155
 156     vs.d = fs;
 157     vt.d = ft;
 158     for (i = 0; i < 8; ++i) {
 159         int r = vs.sb[i] - vt.sb[i];
 160         vs.sb[i] = SATSB(r);
 161     }
 162     return vs.d;
 163 }
 164
 165 uint64_t helper_psubusb(uint64_t fs, uint64_t ft)
 166 {
 167     LMIValue vs, vt;
 168     unsigned int i;
 169
 170     vs.d = fs;
 171     vt.d = ft;
 172     for (i = 0; i < 8; ++i) {
 173         int r = vs.ub[i] - vt.ub[i];
 174         vs.ub[i] = SATUB(r);
 175     }
 176     return vs.d;
 177 }
 178
 179 uint64_t helper_psubsh(uint64_t fs, uint64_t ft)
 180 {
 181     LMIValue vs, vt;
 182     unsigned int i;
 183
 184     vs.d = fs;
 185     vt.d = ft;
 186     for (i = 0; i < 4; ++i) {
 187         int r = vs.sh[i] - vt.sh[i];
 188         vs.sh[i] = SATSH(r);
 189     }
 190     return vs.d;
 191 }
 192
 193 uint64_t helper_psubush(uint64_t fs, uint64_t ft)
 194 {
 195     LMIValue vs, vt;
 196     unsigned int i;
 197
 198     vs.d = fs;
 199     vt.d = ft;
 200     for (i = 0; i < 4; ++i) {
 201         int r = vs.uh[i] - vt.uh[i];
 202         vs.uh[i] = SATUH(r);
 203     }
 204     return vs.d;
 205 }
 206
 207 uint64_t helper_psubb(uint64_t fs, uint64_t ft)
 208 {
 209     LMIValue vs, vt;
 210     unsigned int i;
 211
 212     vs.d = fs;
 213     vt.d = ft;
 214     for (i = 0; i < 8; ++i) {
 215         vs.ub[i] -= vt.ub[i];
 216     }
 217     return vs.d;
 218 }
 219
 220 uint64_t helper_psubh(uint64_t fs, uint64_t ft)
 221 {
 222     LMIValue vs, vt;
 223     unsigned int i;
 224
 225     vs.d = fs;
 226     vt.d = ft;
 227     for (i = 0; i < 4; ++i) {
 228         vs.uh[i] -= vt.uh[i];
 229     }
 230     return vs.d;
 231 }
 232
 233 uint64_t helper_psubw(uint64_t fs, uint64_t ft)
 234 {
 235     LMIValue vs, vt;
 236     unsigned int i;
 237
 238     vs.d = fs;
 239     vt.d = ft;
 240     for (i = 0; i < 2; ++i) {
 241         vs.uw[i] -= vt.uw[i];
 242     }
 243     return vs.d;
 244 }
 245
 246 uint64_t helper_pshufh(uint64_t fs, uint64_t ft)
 247 {
 248     unsigned host = BYTE_ORDER_XOR(3);
 249     LMIValue vd, vs;
 250     unsigned i;
 251
 252     vs.d = fs;
 253     vd.d = 0;
 254     for (i = 0; i < 4; i++, ft >>= 2) {
 255         vd.uh[i ^ host] = vs.uh[(ft & 3) ^ host];
 256     }
 257     return vd.d;
 258 }
 259
 260 uint64_t helper_packsswh(uint64_t fs, uint64_t ft)
 261 {
 262     uint64_t fd = 0;
 263     int64_t tmp;
 264
 265     tmp = (int32_t)(fs >> 0);
 266     tmp = SATSH(tmp);
 267     fd |= (tmp & 0xffff) << 0;
 268
 269     tmp = (int32_t)(fs >> 32);
 270     tmp = SATSH(tmp);
 271     fd |= (tmp & 0xffff) << 16;
 272
 273     tmp = (int32_t)(ft >> 0);
 274     tmp = SATSH(tmp);
 275     fd |= (tmp & 0xffff) << 32;
 276
 277     tmp = (int32_t)(ft >> 32);
 278     tmp = SATSH(tmp);
 279     fd |= (tmp & 0xffff) << 48;
 280
 281     return fd;
 282 }
 283
 284 uint64_t helper_packsshb(uint64_t fs, uint64_t ft)
 285 {
 286     uint64_t fd = 0;
 287     unsigned int i;
 288
 289     for (i = 0; i < 4; ++i) {
 290         int16_t tmp = fs >> (i * 16);
 291         tmp = SATSB(tmp);
 292         fd |= (uint64_t)(tmp & 0xff) << (i * 8);
 293     }
 294     for (i = 0; i < 4; ++i) {
 295         int16_t tmp = ft >> (i * 16);
 296         tmp = SATSB(tmp);
 297         fd |= (uint64_t)(tmp & 0xff) << (i * 8 + 32);
 298     }
 299
 300     return fd;
 301 }
 302
 303 uint64_t helper_packushb(uint64_t fs, uint64_t ft)
 304 {
 305     uint64_t fd = 0;
 306     unsigned int i;
 307
 308     for (i = 0; i < 4; ++i) {
 309         int16_t tmp = fs >> (i * 16);
 310         tmp = SATUB(tmp);
 311         fd |= (uint64_t)(tmp & 0xff) << (i * 8);
 312     }
 313     for (i = 0; i < 4; ++i) {
 314         int16_t tmp = ft >> (i * 16);
 315         tmp = SATUB(tmp);
 316         fd |= (uint64_t)(tmp & 0xff) << (i * 8 + 32);
 317     }
 318
 319     return fd;
 320 }
 321
 322 uint64_t helper_punpcklwd(uint64_t fs, uint64_t ft)
 323 {
 324     return (fs & 0xffffffff) | (ft << 32);
 325 }
 326
 327 uint64_t helper_punpckhwd(uint64_t fs, uint64_t ft)
 328 {
 329     return (fs >> 32) | (ft & ~0xffffffffull);
 330 }
 331
 332 uint64_t helper_punpcklhw(uint64_t fs, uint64_t ft)
 333 {
 334     unsigned host = BYTE_ORDER_XOR(3);
 335     LMIValue vd, vs, vt;
 336
 337     vs.d = fs;
 338     vt.d = ft;
 339     vd.uh[0 ^ host] = vs.uh[0 ^ host];
 340     vd.uh[1 ^ host] = vt.uh[0 ^ host];
 341     vd.uh[2 ^ host] = vs.uh[1 ^ host];
 342     vd.uh[3 ^ host] = vt.uh[1 ^ host];
 343
 344     return vd.d;
 345 }
 346
 347 uint64_t helper_punpckhhw(uint64_t fs, uint64_t ft)
 348 {
 349     unsigned host = BYTE_ORDER_XOR(3);
 350     LMIValue vd, vs, vt;
 351
 352     vs.d = fs;
 353     vt.d = ft;
 354     vd.uh[0 ^ host] = vs.uh[2 ^ host];
 355     vd.uh[1 ^ host] = vt.uh[2 ^ host];
 356     vd.uh[2 ^ host] = vs.uh[3 ^ host];
 357     vd.uh[3 ^ host] = vt.uh[3 ^ host];
 358
 359     return vd.d;
 360 }
 361
 362 uint64_t helper_punpcklbh(uint64_t fs, uint64_t ft)
 363 {
 364     unsigned host = BYTE_ORDER_XOR(7);
 365     LMIValue vd, vs, vt;
 366
 367     vs.d = fs;
 368     vt.d = ft;
 369     vd.ub[0 ^ host] = vs.ub[0 ^ host];
 370     vd.ub[1 ^ host] = vt.ub[0 ^ host];
 371     vd.ub[2 ^ host] = vs.ub[1 ^ host];
 372     vd.ub[3 ^ host] = vt.ub[1 ^ host];
 373     vd.ub[4 ^ host] = vs.ub[2 ^ host];
 374     vd.ub[5 ^ host] = vt.ub[2 ^ host];
 375     vd.ub[6 ^ host] = vs.ub[3 ^ host];
 376     vd.ub[7 ^ host] = vt.ub[3 ^ host];
 377
 378     return vd.d;
 379 }
 380
 381 uint64_t helper_punpckhbh(uint64_t fs, uint64_t ft)
 382 {
 383     unsigned host = BYTE_ORDER_XOR(7);
 384     LMIValue vd, vs, vt;
 385
 386     vs.d = fs;
 387     vt.d = ft;
 388     vd.ub[0 ^ host] = vs.ub[4 ^ host];
 389     vd.ub[1 ^ host] = vt.ub[4 ^ host];
 390     vd.ub[2 ^ host] = vs.ub[5 ^ host];
 391     vd.ub[3 ^ host] = vt.ub[5 ^ host];
 392     vd.ub[4 ^ host] = vs.ub[6 ^ host];
 393     vd.ub[5 ^ host] = vt.ub[6 ^ host];
 394     vd.ub[6 ^ host] = vs.ub[7 ^ host];
 395     vd.ub[7 ^ host] = vt.ub[7 ^ host];
 396
 397     return vd.d;
 398 }
 399
 400 uint64_t helper_pavgh(uint64_t fs, uint64_t ft)
 401 {
 402     LMIValue vs, vt;
 403     unsigned i;
 404
 405     vs.d = fs;
 406     vt.d = ft;
 407     for (i = 0; i < 4; i++) {
 408         vs.uh[i] = (vs.uh[i] + vt.uh[i] + 1) >> 1;
 409     }
 410     return vs.d;
 411 }
 412
 413 uint64_t helper_pavgb(uint64_t fs, uint64_t ft)
 414 {
 415     LMIValue vs, vt;
 416     unsigned i;
 417
 418     vs.d = fs;
 419     vt.d = ft;
 420     for (i = 0; i < 8; i++) {
 421         vs.ub[i] = (vs.ub[i] + vt.ub[i] + 1) >> 1;
 422     }
 423     return vs.d;
 424 }
 425
 426 uint64_t helper_pmaxsh(uint64_t fs, uint64_t ft)
 427 {
 428     LMIValue vs, vt;
 429     unsigned i;
 430
 431     vs.d = fs;
 432     vt.d = ft;
 433     for (i = 0; i < 4; i++) {
 434         vs.sh[i] = (vs.sh[i] >= vt.sh[i] ? vs.sh[i] : vt.sh[i]);
 435     }
 436     return vs.d;
 437 }
 438
 439 uint64_t helper_pminsh(uint64_t fs, uint64_t ft)
 440 {
 441     LMIValue vs, vt;
 442     unsigned i;
 443
 444     vs.d = fs;
 445     vt.d = ft;
 446     for (i = 0; i < 4; i++) {
 447         vs.sh[i] = (vs.sh[i] <= vt.sh[i] ? vs.sh[i] : vt.sh[i]);
 448     }
 449     return vs.d;
 450 }
 451
 452 uint64_t helper_pmaxub(uint64_t fs, uint64_t ft)
 453 {
 454     LMIValue vs, vt;
 455     unsigned i;
 456
 457     vs.d = fs;
 458     vt.d = ft;
 459     for (i = 0; i < 4; i++) {
 460         vs.ub[i] = (vs.ub[i] >= vt.ub[i] ? vs.ub[i] : vt.ub[i]);
 461     }
 462     return vs.d;
 463 }
 464
 465 uint64_t helper_pminub(uint64_t fs, uint64_t ft)
 466 {
 467     LMIValue vs, vt;
 468     unsigned i;
 469
 470     vs.d = fs;
 471     vt.d = ft;
 472     for (i = 0; i < 4; i++) {
 473         vs.ub[i] = (vs.ub[i] <= vt.ub[i] ? vs.ub[i] : vt.ub[i]);
 474     }
 475     return vs.d;
 476 }
 477
 478 uint64_t helper_pcmpeqw(uint64_t fs, uint64_t ft)
 479 {
 480     LMIValue vs, vt;
 481     unsigned i;
 482
 483     vs.d = fs;
 484     vt.d = ft;
 485     for (i = 0; i < 2; i++) {
 486         vs.uw[i] = -(vs.uw[i] == vt.uw[i]);
 487     }
 488     return vs.d;
 489 }
 490
 491 uint64_t helper_pcmpgtw(uint64_t fs, uint64_t ft)
 492 {
 493     LMIValue vs, vt;
 494     unsigned i;
 495
 496     vs.d = fs;
 497     vt.d = ft;
 498     for (i = 0; i < 2; i++) {
 499         vs.uw[i] = -(vs.uw[i] > vt.uw[i]);
 500     }
 501     return vs.d;
 502 }
 503
 504 uint64_t helper_pcmpeqh(uint64_t fs, uint64_t ft)
 505 {
 506     LMIValue vs, vt;
 507     unsigned i;
 508
 509     vs.d = fs;
 510     vt.d = ft;
 511     for (i = 0; i < 4; i++) {
 512         vs.uh[i] = -(vs.uh[i] == vt.uh[i]);
 513     }
 514     return vs.d;
 515 }
 516
 517 uint64_t helper_pcmpgth(uint64_t fs, uint64_t ft)
 518 {
 519     LMIValue vs, vt;
 520     unsigned i;
 521
 522     vs.d = fs;
 523     vt.d = ft;
 524     for (i = 0; i < 4; i++) {
 525         vs.uh[i] = -(vs.uh[i] > vt.uh[i]);
 526     }
 527     return vs.d;
 528 }
 529
 530 uint64_t helper_pcmpeqb(uint64_t fs, uint64_t ft)
 531 {
 532     LMIValue vs, vt;
 533     unsigned i;
 534
 535     vs.d = fs;
 536     vt.d = ft;
 537     for (i = 0; i < 8; i++) {
 538         vs.ub[i] = -(vs.ub[i] == vt.ub[i]);
 539     }
 540     return vs.d;
 541 }
 542
 543 uint64_t helper_pcmpgtb(uint64_t fs, uint64_t ft)
 544 {
 545     LMIValue vs, vt;
 546     unsigned i;
 547
 548     vs.d = fs;
 549     vt.d = ft;
 550     for (i = 0; i < 8; i++) {
 551         vs.ub[i] = -(vs.ub[i] > vt.ub[i]);
 552     }
 553     return vs.d;
 554 }
 555
 556 uint64_t helper_psllw(uint64_t fs, uint64_t ft)
 557 {
 558     LMIValue vs;
 559     unsigned i;
 560
 561     ft &= 0x7f;
 562     if (ft > 31) {
 563         return 0;
 564     }
 565     vs.d = fs;
 566     for (i = 0; i < 2; ++i) {
 567         vs.uw[i] <<= ft;
 568     }
 569     return vs.d;
 570 }
 571
 572 uint64_t helper_psrlw(uint64_t fs, uint64_t ft)
 573 {
 574     LMIValue vs;
 575     unsigned i;
 576
 577     ft &= 0x7f;
 578     if (ft > 31) {
 579         return 0;
 580     }
 581     vs.d = fs;
 582     for (i = 0; i < 2; ++i) {
 583         vs.uw[i] >>= ft;
 584     }
 585     return vs.d;
 586 }
 587
 588 uint64_t helper_psraw(uint64_t fs, uint64_t ft)
 589 {
 590     LMIValue vs;
 591     unsigned i;
 592
 593     ft &= 0x7f;
 594     if (ft > 31) {
 595         ft = 31;
 596     }
 597     vs.d = fs;
 598     for (i = 0; i < 2; ++i) {
 599         vs.sw[i] >>= ft;
 600     }
 601     return vs.d;
 602 }
 603
 604 uint64_t helper_psllh(uint64_t fs, uint64_t ft)
 605 {
 606     LMIValue vs;
 607     unsigned i;
 608
 609     ft &= 0x7f;
 610     if (ft > 15) {
 611         return 0;
 612     }
 613     vs.d = fs;
 614     for (i = 0; i < 4; ++i) {
 615         vs.uh[i] <<= ft;
 616     }
 617     return vs.d;
 618 }
 619
 620 uint64_t helper_psrlh(uint64_t fs, uint64_t ft)
 621 {
 622     LMIValue vs;
 623     unsigned i;
 624
 625     ft &= 0x7f;
 626     if (ft > 15) {
 627         return 0;
 628     }
 629     vs.d = fs;
 630     for (i = 0; i < 4; ++i) {
 631         vs.uh[i] >>= ft;
 632     }
 633     return vs.d;
 634 }
 635
 636 uint64_t helper_psrah(uint64_t fs, uint64_t ft)
 637 {
 638     LMIValue vs;
 639     unsigned i;
 640
 641     ft &= 0x7f;
 642     if (ft > 15) {
 643         ft = 15;
 644     }
 645     vs.d = fs;
 646     for (i = 0; i < 4; ++i) {
 647         vs.sh[i] >>= ft;
 648     }
 649     return vs.d;
 650 }
 651
 652 uint64_t helper_pmullh(uint64_t fs, uint64_t ft)
 653 {
 654     LMIValue vs, vt;
 655     unsigned i;
 656
 657     vs.d = fs;
 658     vt.d = ft;
 659     for (i = 0; i < 4; ++i) {
 660         vs.sh[i] *= vt.sh[i];
 661     }
 662     return vs.d;
 663 }
 664
 665 uint64_t helper_pmulhh(uint64_t fs, uint64_t ft)
 666 {
 667     LMIValue vs, vt;
 668     unsigned i;
 669
 670     vs.d = fs;
 671     vt.d = ft;
 672     for (i = 0; i < 4; ++i) {
 673         int32_t r = vs.sh[i] * vt.sh[i];
 674         vs.sh[i] = r >> 16;
 675     }
 676     return vs.d;
 677 }
 678
 679 uint64_t helper_pmulhuh(uint64_t fs, uint64_t ft)
 680 {
 681     LMIValue vs, vt;
 682     unsigned i;
 683
 684     vs.d = fs;
 685     vt.d = ft;
 686     for (i = 0; i < 4; ++i) {
 687         uint32_t r = vs.uh[i] * vt.uh[i];
 688         vs.uh[i] = r >> 16;
 689     }
 690     return vs.d;
 691 }
 692
 693 uint64_t helper_pmaddhw(uint64_t fs, uint64_t ft)
 694 {
 695     unsigned host = BYTE_ORDER_XOR(3);
 696     LMIValue vs, vt;
 697     uint32_t p0, p1;
 698
 699     vs.d = fs;
 700     vt.d = ft;
 701     p0  = vs.sh[0 ^ host] * vt.sh[0 ^ host];
 702     p0 += vs.sh[1 ^ host] * vt.sh[1 ^ host];
 703     p1  = vs.sh[2 ^ host] * vt.sh[2 ^ host];
 704     p1 += vs.sh[3 ^ host] * vt.sh[3 ^ host];
 705
 706     return ((uint64_t)p1 << 32) | p0;
 707 }
 708
 709 uint64_t helper_pasubub(uint64_t fs, uint64_t ft)
 710 {
 711     LMIValue vs, vt;
 712     unsigned i;
 713
 714     vs.d = fs;
 715     vt.d = ft;
 716     for (i = 0; i < 8; ++i) {
 717         int r = vs.ub[i] - vt.ub[i];
 718         vs.ub[i] = (r < 0 ? -r : r);
 719     }
 720     return vs.d;
 721 }
 722
 723 uint64_t helper_biadd(uint64_t fs)
 724 {
 725     unsigned i, fd;
 726
 727     for (i = fd = 0; i < 8; ++i) {
 728         fd += (fs >> (i * 8)) & 0xff;
 729     }
 730     return fd & 0xffff;
 731 }
 732
 733 uint64_t helper_pmovmskb(uint64_t fs)
 734 {
 735     unsigned fd = 0;
 736
 737     fd |= ((fs >>  7) & 1) << 0;
 738     fd |= ((fs >> 15) & 1) << 1;
 739     fd |= ((fs >> 23) & 1) << 2;
 740     fd |= ((fs >> 31) & 1) << 3;
 741     fd |= ((fs >> 39) & 1) << 4;
 742     fd |= ((fs >> 47) & 1) << 5;
 743     fd |= ((fs >> 55) & 1) << 6;
 744     fd |= ((fs >> 63) & 1) << 7;
 745
 746     return fd & 0xff;
 747 }