Changeset 258710 in webkit


Ignore:
Timestamp:
Mar 19, 2020 10:44:22 AM (4 years ago)
Author:
tpopela@redhat.com
Message:

[JSC][BigEndians] Several JSC stress tests failing
​https://bugs.webkit.org/show_bug.cgi?id=194007

Reviewed by Michael Catanzaro.

Adapt the DataView tests to be able to pass on little endian as well
as the big endian hardware. Do so by introducing method that determine
the endianess and based on its value it saves the expected results in
the right format.

  • stress/dataview-get-cse.js:

(getIsLittleEndian):
(adjustForEndianess):
(test3.foo):
(test3):

  • stress/dataview-jit-get.js:

(getIsLittleEndian):
(test1.adjustForEndianess):
(test1):
(test2.adjustForEndianess):
(test2):
(test3.adjustForEndianess):
(test3):
(adjustForEndianessUint32):
(test4):
(test5):
(test6):
(test7):
(test8):

  • stress/dataview-jit-neuter.js:

(getIsLittleEndian):
(adjustForEndianess):
(test):
(test2):

  • stress/dataview-jit-set-nan.js:

(getIsLittleEndian):
(adjustForEndianessFloat32):
(test):

  • stress/dataview-jit-set.js:

(getIsLittleEndian):
(readHex):
(adjustForEndianessUint16):
(test):
(test2):
(adjustForEndianessUint32):
(test3):
(test4):
(adjustForEndianessFloat32):
(test5):
(adjustForEndianessFloat64):
(test6):
(isLittleEndian): Deleted.

Location:
trunk/JSTests
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/JSTests/ChangeLog

    r258664 r258710  
     12020-03-19  Tomas Popela  <tpopela@redhat.com>
     2
     3        [JSC][BigEndians] Several JSC stress tests failing
     4        https://bugs.webkit.org/show_bug.cgi?id=194007
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        Adapt the DataView tests to be able to pass on little endian as well
     9        as the big endian hardware. Do so by introducing method that determine
     10        the endianess and based on its value it saves the expected results in
     11        the right format.
     12
     13        * stress/dataview-get-cse.js:
     14        (getIsLittleEndian):
     15        (adjustForEndianess):
     16        (test3.foo):
     17        (test3):
     18        * stress/dataview-jit-get.js:
     19        (getIsLittleEndian):
     20        (test1.adjustForEndianess):
     21        (test1):
     22        (test2.adjustForEndianess):
     23        (test2):
     24        (test3.adjustForEndianess):
     25        (test3):
     26        (adjustForEndianessUint32):
     27        (test4):
     28        (test5):
     29        (test6):
     30        (test7):
     31        (test8):
     32        * stress/dataview-jit-neuter.js:
     33        (getIsLittleEndian):
     34        (adjustForEndianess):
     35        (test):
     36        (test2):
     37        * stress/dataview-jit-set-nan.js:
     38        (getIsLittleEndian):
     39        (adjustForEndianessFloat32):
     40        (test):
     41        * stress/dataview-jit-set.js:
     42        (getIsLittleEndian):
     43        (readHex):
     44        (adjustForEndianessUint16):
     45        (test):
     46        (test2):
     47        (adjustForEndianessUint32):
     48        (test3):
     49        (test4):
     50        (adjustForEndianessFloat32):
     51        (test5):
     52        (adjustForEndianessFloat64):
     53        (test6):
     54        (isLittleEndian): Deleted.
     55
    1562020-03-18  Yusuke Suzuki  <ysuzuki@apple.com>
    257

  • trunk/JSTests/stress/dataview-get-cse.js

    r235515 r258710  
    66}
    77
     8function getIsLittleEndian() {
     9    let ab = new ArrayBuffer(2);
     10    let ta = new Int16Array(ab);
     11    ta[0] = 0x0102;
     12    let dv = new DataView(ab);
     13    return dv.getInt16(0, true) === 0x0102;
     14}
     15
     16let isLittleEndian = getIsLittleEndian();
     17
     18function adjustForEndianess(value) {
     19    if (isLittleEndian)
     20        return value;
     21
     22    let ab = new ArrayBuffer(8);
     23    let ta = new Float64Array(ab);
     24    ta[0] = value;
     25    let dv = new DataView(ab);
     26    return dv.getFloat64(0, true);
     27}
    828
    929function test1() {
    … …  
    4262    function foo(dv, ta) {
    4363        let a = dv.getFloat64(0, true);
    44         ta[0] = Math.PI;
     64        ta[0] = adjustForEndianess(Math.PI);
    4565        let b = dv.getFloat64(0, true);
    4666        return [a, b];

  • trunk/JSTests/stress/dataview-jit-get.js

    r235106 r258710  
    66}
    77
    8 function test1() {
    9     function bigEndian(o, i) {
    10         return o.getInt32(i, false);
    11     }
    12     noInline(bigEndian);
    13     function littleEndian(o, i) {
    14         return o.getInt32(i, true);
    15     }
    16     noInline(littleEndian);
    17     function biEndian(o, i, b) {
    18         return o.getInt32(i, b);
    19     }
    20     noInline(biEndian);
    21 
    22     let ab = new ArrayBuffer(4);
    23     let ta = new Int32Array(ab);
    24     ta[0] = 0x01020304;
    25     let dv = new DataView(ab);
    26 
    27     for (let i = 0; i < 10000; ++i) {
    28         assert(bigEndian(dv, 0) === 0x04030201);
    29         assert(littleEndian(dv, 0) === 0x01020304);
    30         if (i % 2)
    31             assert(biEndian(dv, 0, true) === 0x01020304);
    32         else
    33             assert(biEndian(dv, 0, false) === 0x04030201);
    34     }
    35 
    36     for (let i = 0; i < 10000; ++i) {
    37         assert(bigEndian(dv, 0) === 0x04030201);
    38         assert(littleEndian(dv, 0) === 0x01020304);
    39         if (i % 2)
    40             assert(biEndian(dv, 0, true) === 0x01020304);
    41         else
    42             assert(biEndian(dv, 0, false) === 0x04030201);
    43     }
    44 
    45     // Make sure we get the right sign.
    46     ta[0] = -32361386; // 0xfe123456
    47     for (let i = 0; i < 10000; ++i) {
    48         assert(bigEndian(dv, 0) === 0x563412fe);
    49         assert(littleEndian(dv, 0) === -32361386);
    50         if (i % 2)
    51             assert(biEndian(dv, 0, true) === -32361386);
    52         else
    53             assert(biEndian(dv, 0, false) === 0x563412fe);
    54     }
    55 
    56     // -2146290602 == (int)0x80123456
    57     ta[0] = 0x56341280;
    58     for (let i = 0; i < 10000; ++i) {
    59         assert(bigEndian(dv, 0) === -2146290602);
    60         assert(littleEndian(dv, 0) === 0x56341280);
    61         if (i % 2)
    62             assert(biEndian(dv, 0, true) === 0x56341280);
    63         else
    64             assert(biEndian(dv, 0, false) === -2146290602);
    65     }
    66 }
    67 test1();
    68 
    69 function test2() {
    70     function bigEndian(o, i) {
    71         return o.getInt16(i, false);
    72     }
    73     noInline(bigEndian);
    74     function littleEndian(o, i) {
    75         return o.getInt16(i, true);
    76     }
    77     noInline(littleEndian);
    78     function biEndian(o, i, b) {
    79         return o.getInt16(i, b);
    80     }
    81     noInline(biEndian);
    82 
     8function getIsLittleEndian() {
    839    let ab = new ArrayBuffer(2);
    8410    let ta = new Int16Array(ab);
    8511    ta[0] = 0x0102;
    8612    let dv = new DataView(ab);
     13    return dv.getInt16(0, true) === 0x0102;
     14}
     15
     16let isLittleEndian = getIsLittleEndian();
     17
     18function test1() {
     19    function bigEndian(o, i) {
     20        return o.getInt32(i, false);
     21    }
     22    noInline(bigEndian);
     23    function littleEndian(o, i) {
     24        return o.getInt32(i, true);
     25    }
     26    noInline(littleEndian);
     27    function biEndian(o, i, b) {
     28        return o.getInt32(i, b);
     29    }
     30    noInline(biEndian);
     31    function adjustForEndianess(value) {
     32        if (isLittleEndian)
     33            return value;
     34
     35        let ab = new ArrayBuffer(4);
     36        let ta = new Int32Array(ab);
     37        ta[0] = value;
     38        let dv = new DataView(ab);
     39        return dv.getInt32(0, true);
     40    }
     41
     42    let ab = new ArrayBuffer(4);
     43    let ta = new Int32Array(ab);
     44    ta[0] = adjustForEndianess(0x01020304);
     45    let dv = new DataView(ab);
     46
     47    for (let i = 0; i < 10000; ++i) {
     48        assert(bigEndian(dv, 0) === 0x04030201);
     49        assert(littleEndian(dv, 0) === 0x01020304);
     50        if (i % 2)
     51            assert(biEndian(dv, 0, true) === 0x01020304);
     52        else
     53            assert(biEndian(dv, 0, false) === 0x04030201);
     54    }
     55
     56    for (let i = 0; i < 10000; ++i) {
     57        assert(bigEndian(dv, 0) === 0x04030201);
     58        assert(littleEndian(dv, 0) === 0x01020304);
     59        if (i % 2)
     60            assert(biEndian(dv, 0, true) === 0x01020304);
     61        else
     62            assert(biEndian(dv, 0, false) === 0x04030201);
     63    }
     64
     65    // Make sure we get the right sign.
     66    ta[0] = adjustForEndianess(-32361386); // 0xfe123456
     67    for (let i = 0; i < 10000; ++i) {
     68        assert(bigEndian(dv, 0) === 0x563412fe);
     69        assert(littleEndian(dv, 0) === -32361386);
     70        if (i % 2)
     71            assert(biEndian(dv, 0, true) === -32361386);
     72        else
     73            assert(biEndian(dv, 0, false) === 0x563412fe);
     74    }
     75
     76    // -2146290602 == (int)0x80123456
     77    ta[0] = adjustForEndianess(0x56341280);
     78    for (let i = 0; i < 10000; ++i) {
     79        assert(bigEndian(dv, 0) === -2146290602);
     80        assert(littleEndian(dv, 0) === 0x56341280);
     81        if (i % 2)
     82            assert(biEndian(dv, 0, true) === 0x56341280);
     83        else
     84            assert(biEndian(dv, 0, false) === -2146290602);
     85    }
     86}
     87test1();
     88
     89function test2() {
     90    function bigEndian(o, i) {
     91        return o.getInt16(i, false);
     92    }
     93    noInline(bigEndian);
     94    function littleEndian(o, i) {
     95        return o.getInt16(i, true);
     96    }
     97    noInline(littleEndian);
     98    function biEndian(o, i, b) {
     99        return o.getInt16(i, b);
     100    }
     101    noInline(biEndian);
     102    function adjustForEndianess(value) {
     103        if (isLittleEndian)
     104            return value;
     105
     106        let ab = new ArrayBuffer(2);
     107        let ta = new Int16Array(ab);
     108        ta[0] = value;
     109        let dv = new DataView(ab);
     110        return dv.getInt16(0, true);
     111    }
     112
     113    let ab = new ArrayBuffer(2);
     114    let ta = new Int16Array(ab);
     115    ta[0] = adjustForEndianess(0x0102);
     116    let dv = new DataView(ab);
    87117
    88118    for (let i = 0; i < 10000; ++i) {
    … …  
    96126
    97127    // Check sign.
    98     ta[0] = -512; // 0xfe00
     128    ta[0] = adjustForEndianess(-512); // 0xfe00
    99129    for (let i = 0; i < 10000; ++i) {
    100130        assert(bigEndian(dv, 0) === 0x00fe);
    … …  
    107137
    108138    // Check sign extension.
    109     ta[0] = 0x00fe;
     139    ta[0] = adjustForEndianess(0x00fe);
    110140    for (let i = 0; i < 10000; ++i) {
    111141        assert(bigEndian(dv, 0) === -512);
    … …  
    132162    }
    133163    noInline(biEndian);
     164    function adjustForEndianess(value) {
     165        if (isLittleEndian)
     166            return value;
     167
     168        let ab = new ArrayBuffer(4);
     169        let ta = new Float32Array(ab);
     170        ta[0] = value;
     171        let dv = new DataView(ab);
     172        return dv.getFloat32(0, true);
     173    }
    134174
    135175    let ab = new ArrayBuffer(4);
    … …  
    139179
    140180    const flipped = -5.1162437589918884e-21;
    141     ta[0] = normal;
     181    ta[0] = adjustForEndianess(normal);
    142182
    143183    let dv = new DataView(ab);
    … …  
    153193test3();
    154194
     195function adjustForEndianessUint32(value) {
     196    if (isLittleEndian)
     197        return value;
     198
     199    let ab = new ArrayBuffer(4);
     200    let ta = new Uint32Array(ab);
     201    ta[0] = value;
     202    let dv = new DataView(ab);
     203    return dv.getUint32(0, true);
     204}
     205
    155206function test4() {
    156207    function bigEndian(o, i) {
    … …  
    169220    let ab = new ArrayBuffer(4);
    170221    let ta = new Uint32Array(ab);
    171     ta[0] = 0xa0b0d0f0;
     222    ta[0] = adjustForEndianessUint32(0xa0b0d0f0);
    172223
    173224    let dv = new DataView(ab);
    … …  
    199250    let ab = new ArrayBuffer(4);
    200251    let ta = new Uint32Array(ab);
    201     ta[0] = 0xa0b0d0f0;
     252    ta[0] = adjustForEndianessUint32(0xa0b0d0f0);
    202253
    203254    let dv = new DataView(ab);
    … …  
    240291    let ab = new ArrayBuffer(4);
    241292    let ta = new Uint32Array(ab);
    242     ta[0] = 0xa070fa01;
     293    ta[0] = adjustForEndianessUint32(0xa070fa01);
    243294
    244295    let dv = new DataView(ab);
    … …  
    273324    let ab = new ArrayBuffer(4);
    274325    let ta = new Uint32Array(ab);
    275     ta[0] = 0xa070fa01;
     326    ta[0] = adjustForEndianessUint32(0xa070fa01);
    276327
    277328    let dv = new DataView(ab);
    … …  
    293344    let ab = new ArrayBuffer(4);
    294345    let ta = new Uint32Array(ab);
    295     ta[0] = 0xa070fa01;
     346    ta[0] = adjustForEndianessUint32(0xa070fa01);
    296347
    297348    let dv = new DataView(ab);

  • trunk/JSTests/stress/dataview-jit-neuter.js

    r235106 r258710  
    44    if (!b)
    55        throw new Error("Bad!");
     6}
     7
     8function getIsLittleEndian() {
     9    let ab = new ArrayBuffer(2);
     10    let ta = new Int16Array(ab);
     11    ta[0] = 0x0102;
     12    let dv = new DataView(ab);
     13    return dv.getInt16(0, true) === 0x0102;
     14}
     15
     16let isLittleEndian = getIsLittleEndian();
     17
     18function adjustForEndianess(value) {
     19    if (isLittleEndian)
     20        return value;
     21
     22    let ab = new ArrayBuffer(4);
     23    let ta = new Uint32Array(ab);
     24    ta[0] = value;
     25    let dv = new DataView(ab);
     26    return dv.getUint32(0, true);
    627}
    728
    … …  
    1435    let ab = new ArrayBuffer(4);
    1536    let ta = new Uint32Array(ab);
    16     ta[0] = 0xa070fa01;
     37    ta[0] = adjustForEndianess(0xa070fa01);
    1738    let dv = new DataView(ab);
    1839
    … …  
    4162    let ab = new ArrayBuffer(4);
    4263    let ta = new Uint32Array(ab);
    43     ta[0] = 0xa070fa01;
     64    ta[0] = adjustForEndianess(0xa070fa01);
    4465    let dv = new DataView(ab);
    4566

  • trunk/JSTests/stress/dataview-jit-set-nan.js

    r236684 r258710  
    66    if (!b)
    77        throw new Error;
     8}
     9
     10function getIsLittleEndian() {
     11    let ab = new ArrayBuffer(2);
     12    let ta = new Int16Array(ab);
     13    ta[0] = 0x0102;
     14    let dv = new DataView(ab);
     15    return dv.getInt16(0, true) === 0x0102;
     16}
     17
     18let isLittleEndian = getIsLittleEndian();
     19
     20function adjustForEndianessFloat32(value) {
     21    if (isLittleEndian)
     22        return value;
     23
     24    let ab = new ArrayBuffer(4);
     25    let ta = new Float32Array(ab);
     26    ta[0] = value;
     27    let dv = new DataView(ab);
     28    return dv.getFloat32(0, true);
    829}
    930
    … …  
    3051
    3152    for (let i = 0; i < 10000; ++i) {
    32         storeLittleEndian(dv, 0, 1.5);
     53        storeLittleEndian(dv, 0, adjustForEndianessFloat32(1.5));
    3354        assert(arr[0] === 1.5);
    3455
    35         storeLittleEndian(dv, 0, 12912.124123215122);
     56        // The right way how to process this test is to uncomment the line below
     57        // and comment out the line below it. But strangely it doesn't work. I
     58        // opened https://bugs.webkit.org/show_bug.cgi?id=209289 for it.
     59        //storeLittleEndian(dv, 0, adjustForEndianessFloat32(12912.124123215122));
     60        store(dv, 0, 12912.124123215122, isLittleEndian);
    3661        assert(arr[0] === 12912.1240234375);
    3762        assert(bits[0] === 0x4649c07f);
    3863
    39         storeLittleEndian(dv, 0, NaN);
     64        storeLittleEndian(dv, 0, adjustForEndianessFloat32(NaN));
    4065        assert(isNaN(arr[0]));
    4166        assert(bits[0] === 0x7FC00000);
    4267
    43         storeLittleEndian(dv, 0, 2.3879393e-38);
     68        storeLittleEndian(dv, 0, adjustForEndianessFloat32(2.3879393e-38));
    4469        assert(arr[0] === 2.387939260590663e-38);
    4570        assert(bits[0] === 0x01020304);
    4671
    47         storeBigEndian(dv, 0, 2.3879393e-38);
     72        storeBigEndian(dv, 0, adjustForEndianessFloat32(2.3879393e-38));
    4873        assert(arr[0] === 1.539989614439558e-36);
    4974        assert(bits[0] === 0x04030201);

  • trunk/JSTests/stress/dataview-jit-set.js

    r236684 r258710  
    66}
    77
     8function getIsLittleEndian() {
     9    let ab = new ArrayBuffer(2);
     10    let ta = new Int16Array(ab);
     11    ta[0] = 0x0102;
     12    let dv = new DataView(ab);
     13    return dv.getInt16(0, true) === 0x0102;
     14}
     15
     16let isLittleEndian = getIsLittleEndian();
     17
    818function readHex(dv, bytes) {
    9     function isLittleEndian() {
    10         let b = new ArrayBuffer(4);
    11         let dv = new DataView(b);
    12         dv.setInt32(0, 0x00112233, true);
    13         return dv.getUint8(0) === 0x33;
    14     }
    1519    let str = "";
    1620    function readByte(i) {
    … …  
    2226        return b;
    2327    }
    24     if (isLittleEndian()) {
     28    if (isLittleEndian) {
    2529        for (let i = bytes; i--;)
    2630            str = str + readByte(i);
    … …  
    3640    let b = new ArrayBuffer(4);
    3741    let dv = new DataView(b);
    38     dv.setInt32(0, 0x00112233, true);
     42    dv.setInt32(0, 0x00112233, isLittleEndian);
    3943    assert(readHex(dv, 4) === "0x00112233");
     44}
     45
     46function adjustForEndianessUint16(value) {
     47    if (isLittleEndian)
     48        return value;
     49
     50    let ab = new ArrayBuffer(4);
     51    let ta = new Uint16Array(ab);
     52    ta[0] = value;
     53    let dv = new DataView(ab);
     54    return dv.getUint16(0, true);
    4055}
    4156
    … …  
    6176
    6277    for (let i = 0; i < 10000; ++i) {
    63         storeLittleEndian(dv, 0, 0xfaba);
     78        storeLittleEndian(dv, 0, adjustForEndianessUint16(0xfaba));
    6479        assert(arr[0] === 0xfaba);
    6580
    66         store(dv, 0, 0xabcd, true);
     81        store(dv, 0, adjustForEndianessUint16(0xabcd), true);
    6782        assert(arr[0] === 0xabcd);
    6883
    69         store(dv, 0, 0xbadbeef, true);
     84        store(dv, 0, adjustForEndianessUint16(0xbadbeef), true);
    7085        assert(arr[0] === 0xbeef);
    7186
    72         storeLittleEndian(dv, 0, 0xbb4db33f, true);
     87        storeLittleEndian(dv, 0, adjustForEndianessUint16(0xbb4db33f), true);
    7388        assert(arr[0] === 0xb33f);
    7489
    75         storeBigEndian(dv, 0, 0xfada);
     90        storeBigEndian(dv, 0, adjustForEndianessUint16(0xfada));
    7691        assert(arr[0] === 0xdafa);
    7792
    78         storeBigEndian(dv, 0, 0x12ab);
     93        storeBigEndian(dv, 0, adjustForEndianessUint16(0x12ab));
    7994        assert(arr[0] === 0xab12);
    8095
    81         store(dv, 0, 0x1234, false);
     96        store(dv, 0, adjustForEndianessUint16(0x1234), false);
    8297        assert(arr[0] === 0x3412);
    8398
    84         store(dv, 0, 0x0102, false);
     99        store(dv, 0, adjustForEndianessUint16(0x0102), false);
    85100        assert(arr[0] === 0x0201);
    86101
    87         store(dv, 0, -1, false);
     102        store(dv, 0, adjustForEndianessUint16(-1), false);
    88103        assert(arr[0] === 0xffff);
    89104
    90         store(dv, 0, -2, false);
     105        store(dv, 0, adjustForEndianessUint16(-2), false);
    91106        assert(arr[0] === 0xfeff);
    92107
    93         storeBigEndian(dv, 0, -1);
     108        storeBigEndian(dv, 0, adjustForEndianessUint16(-1));
    94109        assert(arr[0] === 0xffff);
    95110
    96         storeBigEndian(dv, 0, -2);
     111        storeBigEndian(dv, 0, adjustForEndianessUint16(-2));
    97112        assert(arr[0] === 0xfeff);
    98113
    99         storeBigEndian(dv, 0, -2147483648);
     114        storeBigEndian(dv, 0, adjustForEndianessUint16(-2147483648));
    100115        assert(arr[0] === 0x0000);
    101116
    102         storeLittleEndian(dv, 0, -2147483648);
     117        storeLittleEndian(dv, 0, adjustForEndianessUint16(-2147483648));
    103118        assert(arr[0] === 0x0000);
    104119
    105         storeLittleEndian(dv, 0, -2147478988);
     120        storeLittleEndian(dv, 0, adjustForEndianessUint16(-2147478988));
    106121        assert(arr[0] === 0x1234);
    107122
    108         storeBigEndian(dv, 0, -2147478988);
     123        storeBigEndian(dv, 0, adjustForEndianessUint16(-2147478988));
    109124        assert(arr[0] === 0x3412);
    110125    }
    … …  
    133148
    134149    for (let i = 0; i < 10000; ++i) {
    135         storeLittleEndian(dv, 0, 0xfaba);
     150        storeLittleEndian(dv, 0, adjustForEndianessUint16(0xfaba));
    136151        assert(arr[0] === 0xfaba);
    137152
    138         store(dv, 0, 0xabcd, true);
     153        store(dv, 0, adjustForEndianessUint16(0xabcd), true);
    139154        assert(arr[0] === 0xabcd);
    140155
    141         store(dv, 0, 0xbadbeef, true);
     156        store(dv, 0, adjustForEndianessUint16(0xbadbeef), true);
    142157        assert(arr[0] === 0xbeef);
    143158
    144         storeLittleEndian(dv, 0, 0xbb4db33f, true);
     159        storeLittleEndian(dv, 0, adjustForEndianessUint16(0xbb4db33f), true);
    145160        assert(arr[0] === 0xb33f);
    146161
    147         storeBigEndian(dv, 0, 0xfada);
     162        storeBigEndian(dv, 0, adjustForEndianessUint16(0xfada));
    148163        assert(arr[0] === 0xdafa);
    149164
    150         storeBigEndian(dv, 0, 0x12ab);
     165        storeBigEndian(dv, 0, adjustForEndianessUint16(0x12ab));
    151166        assert(arr[0] === 0xab12);
    152167
    153         store(dv, 0, 0x1234, false);
     168        store(dv, 0, adjustForEndianessUint16(0x1234), false);
    154169        assert(arr[0] === 0x3412);
    155170
    156         store(dv, 0, 0x0102, false);
     171        store(dv, 0, adjustForEndianessUint16(0x0102), false);
    157172        assert(arr[0] === 0x0201);
    158173
    159         store(dv, 0, -1, false);
     174        store(dv, 0, adjustForEndianessUint16(-1), false);
    160175        assert(arr[0] === 0xffff);
    161176
    162         store(dv, 0, -2, false);
     177        store(dv, 0, adjustForEndianessUint16(-2), false);
    163178        assert(arr[0] === 0xfeff);
    164179
    165         storeBigEndian(dv, 0, -1);
     180        storeBigEndian(dv, 0, adjustForEndianessUint16(-1));
    166181        assert(arr[0] === 0xffff);
    167182
    168         storeBigEndian(dv, 0, -2);
     183        storeBigEndian(dv, 0, adjustForEndianessUint16(-2));
    169184        assert(arr[0] === 0xfeff);
    170185
    171         storeBigEndian(dv, 0, -2147483648);
     186        storeBigEndian(dv, 0, adjustForEndianessUint16(-2147483648));
    172187        assert(arr[0] === 0x0000);
    173188
    174         storeLittleEndian(dv, 0, -2147483648);
     189        storeLittleEndian(dv, 0, adjustForEndianessUint16(-2147483648));
    175190        assert(arr[0] === 0x0000);
    176191
    177         storeLittleEndian(dv, 0, -2147478988);
     192        storeLittleEndian(dv, 0, adjustForEndianessUint16(-2147478988));
    178193        assert(arr[0] === 0x1234);
    179194
    180         storeBigEndian(dv, 0, -2147478988);
     195        storeBigEndian(dv, 0, adjustForEndianessUint16(-2147478988));
    181196        assert(arr[0] === 0x3412);
    182197    }
    183198}
    184199test2();
     200
     201function adjustForEndianessUint32(value) {
     202    if (isLittleEndian)
     203        return value;
     204
     205    let ab = new ArrayBuffer(4);
     206    let ta = new Uint32Array(ab);
     207    ta[0] = value;
     208    let dv = new DataView(ab);
     209    return dv.getUint32(0, true);
     210}
    185211
    186212function test3() {
    … …  
    206232
    207233    for (let i = 0; i < 10000; ++i) {
    208         storeLittleEndian(dv, 0, 0xffffffff);
     234        storeLittleEndian(dv, 0, adjustForEndianessUint32(0xffffffff));
    209235        assert(arr[0] === 0xffffffff);
    210236        assert(arr2[0] === -1);
    211237
    212         storeLittleEndian(dv, 0, 0xffaabbcc);
     238        storeLittleEndian(dv, 0, adjustForEndianessUint32(0xffaabbcc));
    213239        assert(arr[0] === 0xffaabbcc);
    214240
    215         storeBigEndian(dv, 0, 0x12345678);
     241        storeBigEndian(dv, 0, adjustForEndianessUint32(0x12345678));
    216242        assert(arr[0] === 0x78563412);
    217243
    218         storeBigEndian(dv, 0, 0xffaabbcc);
     244        storeBigEndian(dv, 0, adjustForEndianessUint32(0xffaabbcc));
    219245        assert(arr[0] === 0xccbbaaff);
    220246
    221         store(dv, 0, 0xfaeadaca, false);
     247        store(dv, 0, adjustForEndianessUint32(0xfaeadaca), false);
    222248        assert(arr[0] === 0xcadaeafa);
    223249
    224         store(dv, 0, 0xcadaeafa, false);
     250        store(dv, 0, adjustForEndianessUint32(0xcadaeafa), false);
    225251        assert(arr2[0] === -85271862);
    226252
    227         store(dv, 0, 0x12345678, false);
     253        store(dv, 0, adjustForEndianessUint32(0x12345678), false);
    228254        assert(arr[0] === 0x78563412);
    229255
    230         storeBigEndian(dv, 0, 0xbeeffeeb);
     256        storeBigEndian(dv, 0, adjustForEndianessUint32(0xbeeffeeb));
    231257        assert(arr2[0] === -335614018);
    232258    }
    … …  
    256282
    257283    for (let i = 0; i < 10000; ++i) {
    258         storeLittleEndian(dv, 0, 0xffffffff);
     284        storeLittleEndian(dv, 0, adjustForEndianessUint32(0xffffffff));
    259285        assert(arr[0] === 0xffffffff);
    260286        assert(arr2[0] === -1);
    261287
    262         storeLittleEndian(dv, 0, 0xffaabbcc);
     288        storeLittleEndian(dv, 0, adjustForEndianessUint32(0xffaabbcc));
    263289        assert(arr[0] === 0xffaabbcc);
    264290
    265         storeBigEndian(dv, 0, 0x12345678);
     291        storeBigEndian(dv, 0, adjustForEndianessUint32(0x12345678));
    266292        assert(arr[0] === 0x78563412);
    267293
    268         storeBigEndian(dv, 0, 0xffaabbcc);
     294        storeBigEndian(dv, 0, adjustForEndianessUint32(0xffaabbcc));
    269295        assert(arr[0] === 0xccbbaaff);
    270296
    271         store(dv, 0, 0xfaeadaca, false);
     297        store(dv, 0, adjustForEndianessUint32(0xfaeadaca), false);
    272298        assert(arr[0] === 0xcadaeafa);
    273299
    274         store(dv, 0, 0xcadaeafa, false);
     300        store(dv, 0, adjustForEndianessUint32(0xcadaeafa), false);
    275301        assert(arr2[0] === -85271862);
    276302
    277         store(dv, 0, 0x12345678, false);
     303        store(dv, 0, adjustForEndianessUint32(0x12345678), false);
    278304        assert(arr[0] === 0x78563412);
    279305
    280         storeBigEndian(dv, 0, 0xbeeffeeb);
     306        storeBigEndian(dv, 0, adjustForEndianessUint32(0xbeeffeeb));
    281307        assert(arr2[0] === -335614018);
    282308    }
    283309}
    284310test4();
     311
     312function adjustForEndianessFloat32(value) {
     313    if (isLittleEndian)
     314        return value;
     315
     316    let ab = new ArrayBuffer(4);
     317    let ta = new Float32Array(ab);
     318    ta[0] = value;
     319    let dv = new DataView(ab);
     320    return dv.getFloat32(0, true);
     321}
    285322
    286323function test5() {
    … …  
    306343
    307344    for (let i = 0; i < 10000; ++i) {
    308         storeLittleEndian(dv, 0, 1.5);
     345        storeLittleEndian(dv, 0, adjustForEndianessFloat32(1.5));
    309346        assert(arr[0] === 1.5);
    310347
    311         storeLittleEndian(dv, 0, 12912.124123215122);
     348        store(dv, 0, 12912.124123215122, isLittleEndian);
     349        assert(bits[0] === 0x4649c07f);
    312350        assert(arr[0] === 12912.1240234375);
    313         assert(bits[0] === 0x4649c07f);
    314 
    315         storeLittleEndian(dv, 0, NaN);
     351
     352        storeLittleEndian(dv, 0, adjustForEndianessFloat32(NaN));
    316353        assert(isNaN(arr[0]));
    317354
    318         storeLittleEndian(dv, 0, 2.3879393e-38);
     355        storeLittleEndian(dv, 0, adjustForEndianessFloat32(2.3879393e-38));
    319356        assert(arr[0] === 2.387939260590663e-38);
    320357        assert(bits[0] === 0x01020304);
    321358
    322         storeBigEndian(dv, 0, 2.3879393e-38);
     359        storeBigEndian(dv, 0, adjustForEndianessFloat32(2.3879393e-38));
    323360        assert(arr[0] === 1.539989614439558e-36);
    324361        assert(bits[0] === 0x04030201);
    … …  
    327364test5();
    328365
     366function adjustForEndianessFloat64(value) {
     367    if (isLittleEndian)
     368        return value;
     369
     370    let ab = new ArrayBuffer(8);
     371    let ta = new Float64Array(ab);
     372    ta[0] = value;
     373    let dv = new DataView(ab);
     374    return dv.getFloat64(0, true);
     375}
     376
    329377function test6() {
    330378    function storeLittleEndian(dv, index, value) {
    … …  
    348396
    349397    for (let i = 0; i < 10000; ++i) {
    350         storeLittleEndian(dv, 0, NaN);
     398        storeLittleEndian(dv, 0, adjustForEndianessFloat64(NaN));
    351399        assert(isNaN(arr[0]));
    352400
    353         storeLittleEndian(dv, 0, -2.5075187084135162e+284);
     401        storeLittleEndian(dv, 0, adjustForEndianessFloat64(-2.5075187084135162e+284));
    354402        assert(arr[0] === -2.5075187084135162e+284);
    355403        assert(readHex(dv, 8) === "0xfafafafafafafafa");
    356404
    357         store(dv, 0, 124.553, true);
     405        store(dv, 0, adjustForEndianessFloat64(124.553), true);
    358406        assert(readHex(dv, 8) === "0x405f23645a1cac08");
    359407
    360         store(dv, 0, Infinity, true);
     408        store(dv, 0, adjustForEndianessFloat64(Infinity), true);
    361409        assert(readHex(dv, 8) === "0x7ff0000000000000");
    362410
    363         store(dv, 0, Infinity, false);
     411        store(dv, 0, adjustForEndianessFloat64(Infinity), false);
    364412        assert(readHex(dv, 8) === "0x000000000000f07f");
    365413
    366         store(dv, 0, -Infinity, true);
     414        store(dv, 0, adjustForEndianessFloat64(-Infinity), true);
    367415        assert(readHex(dv, 8) === "0xfff0000000000000");
    368416
    369         storeBigEndian(dv, 0, -2.5075187084135162e+284);
     417        storeBigEndian(dv, 0, adjustForEndianessFloat64(-2.5075187084135162e+284));
    370418        assert(arr[0] === -2.5075187084135162e+284);
    371419        assert(readHex(dv, 8) === "0xfafafafafafafafa");
    372420
    373         storeBigEndian(dv, 0, 124.553);
     421        storeBigEndian(dv, 0, adjustForEndianessFloat64(124.553));
    374422        assert(readHex(dv, 8) === "0x08ac1c5a64235f40");
    375423    }
Note: See TracChangeset for help on using the changeset viewer.