git.saurik.com Git - apple/javascriptcore.git/blob - tests/stress/get-by-val-out-of-bounds-basics.js

1 // Get early out-of-bound data.

 function opaqueGetByValOnInt32ArrayEarlyOutOfBounds(array, index)

3 {

4 return array[index];

5 }

6 noInline(opaqueGetByValOnInt32ArrayEarlyOutOfBounds);

8 function testInt32ArrayEarlyOutOfBounds()

9 {

10 // Warm up with an immediate out of bounds.

     var int32Array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

     for (var i = 0; i <= 10; ++i) {

         var value = opaqueGetByValOnInt32ArrayEarlyOutOfBounds(int32Array, i);

         if ((i < 10 && value !== i) || (i >= 10 && value !== undefined))

             throw "Failed opaqueGetByValOnInt32ArrayEarlyOutOfBounds(int32Array, i) warmup with i = " + i + " value = " + value;

16 }

18 // We then do plenty of in-bounds accesses.

     for (var i = 0; i < 1e4; ++i) {

         for (var j = 0; j < 10; ++j) {

             var value = opaqueGetByValOnInt32ArrayEarlyOutOfBounds(int32Array, j);

             if (j < 10 && value !== j)

                 throw "Failed opaqueGetByValOnInt32ArrayEarlyOutOfBounds(int32Array, j) in-bounds with j = " + j + " value = " + value;

24 }

25 }

27 // Followed by plenty of out-of-bounds accesses.

     for (var i = 0; i < 1e4; ++i) {

         for (var j = 0; j <= 10; ++j) {

             var value = opaqueGetByValOnInt32ArrayEarlyOutOfBounds(int32Array, j);

             if ((j < 10 && value !== j) || (j >= 10 && value !== undefined))

                 throw "Failed opaqueGetByValOnInt32ArrayEarlyOutOfBounds(int32Array, j) out-of-bounds with j = " + j + " value = " + value;

33 }

34 }

35 }

36 testInt32ArrayEarlyOutOfBounds();

38 // One more access, with a completely different array type.

39 function testIndexingTypeChangesOnInt32Array()

40 {

     var doubleArray = [-0, 5.5, -42.1];

     var value = opaqueGetByValOnInt32ArrayEarlyOutOfBounds(doubleArray, 0);

     if (value || 1 / value !== -Infinity)

44 throw "Failed opaqueGetByValOnInt32ArrayEarlyOutOfBounds(doubleArray, 0)";

     var value = opaqueGetByValOnInt32ArrayEarlyOutOfBounds(doubleArray, 1);

     if (value !== 5.5)

47 throw "Failed opaqueGetByValOnInt32ArrayEarlyOutOfBounds(doubleArray, 1)";

     var value = opaqueGetByValOnInt32ArrayEarlyOutOfBounds(doubleArray, 2);

     if (value !== -42.1)

50 throw "Failed opaqueGetByValOnInt32ArrayEarlyOutOfBounds(doubleArray, 2)";

51 }

52 testIndexingTypeChangesOnInt32Array();

56 // Get out-of-bound data after a thousand run.

 function opaqueGetByValOnStringArrayHotOutOfBounds(array, index)

58 {

59 return array[index];

60 }

61 noInline(opaqueGetByValOnStringArrayHotOutOfBounds);

63 function testStringArrayHotOutOfBounds()

64 {

65 // Warm up with in bounds access.

     var stringArray = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];

     for (var i = 0; i < 1e2; ++i) {

         for (var j = 0; j < 10; ++j) {

             var value = opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, j);

             if (value !== "" + j)

                 throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, j) in-bounds with j = " + j + " value = " + value;

72 }

73 }

75 // Do a single out of bounds after warmup.

     var value = opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, 10);

     if (value !== undefined)

         throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, 10) with i = " + i + " value = " + value;

80 // We then do plenty of in-bounds accesses.

     for (var i = 0; i < 1e3; ++i) {

         for (var j = 0; j < 10; ++j) {

             var value = opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, j);

             if (value !== "" + j)

                 throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, j) in-bounds with j = " + j + " value = " + value;

86 }

87 }

89 // Followed by plenty of out-of-bounds accesses.

     for (var i = 0; i < 1e3; ++i) {

         for (var j = 0; j <= 10; ++j) {

             var value = opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, j);

             if ((j < 10 && value !== "" + j) || (j >= 10 && value !== undefined))

                 throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(stringArray, j) out-of-bounds with j = " + j + " value = " + value;

95 }

96 }

97 }

98 testStringArrayHotOutOfBounds();

100 function testIndexingTypeChangesOnStringArray()

101 {

     var doubleArray = [-0, 5.5, -42.1];

     var value = opaqueGetByValOnStringArrayHotOutOfBounds(doubleArray, 0);

     if (value || 1 / value !== -Infinity)

105 throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(doubleArray, 0)";

     var value = opaqueGetByValOnStringArrayHotOutOfBounds(doubleArray, 1);

     if (value !== 5.5)

108 throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(doubleArray, 1)";

     var value = opaqueGetByValOnStringArrayHotOutOfBounds(doubleArray, 2);

     if (value !== -42.1)

111 throw "Failed opaqueGetByValOnStringArrayHotOutOfBounds(doubleArray, 2)";

112 }

113 testIndexingTypeChangesOnStringArray();

114

115

116

117 // Get out-of-bound data after a thousand run, but from a different array type.

 function opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(array, index)

119 {

120 return array[index];

121 }

122 noInline(opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds);

123

124 function testStringAndInt32ArrayHotOutOfBounds()

125 {

126 // Warm up with in bounds access.

     var stringArray = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];

     for (var i = 0; i < 1e2; ++i) {

         for (var j = 0; j < 10; ++j) {

             var value = opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, j);

             if (value !== "" + j)

                 throw "Failed opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, j) in-bounds with j = " + j + " value = " + value;

133 }

134 }

135

136 // Do a single out of bounds after warmup.

     var int32Array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

     var value = opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(int32Array, 10);

     if (value !== undefined)

         throw "Failed opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, 10) with i = " + i + " value = " + value;

141

142 // We then do plenty of in-bounds accesses.

     for (var i = 0; i < 1e3; ++i) {

         for (var j = 0; j < 10; ++j) {

             var value = opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, j);

             if (value !== "" + j)

                 throw "Failed opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, j) in-bounds with j = " + j + " value = " + value;

148

             var value = opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(int32Array, j);

150 if (value !== j)

                 throw "Failed opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(int32Array, j) in-bounds with j = " + j + " value = " + value;

152 }

153 }

154

155 // Followed by plenty of out-of-bounds accesses.

     for (var i = 0; i < 1e3; ++i) {

         for (var j = 0; j <= 10; ++j) {

             var value = opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(int32Array, j);

             if ((j < 10 && value !== j) || (j >= 10 && value !== undefined))

                 throw "Failed opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(int32Array, j) out-of-bounds with j = " + j + " value = " + value;

161

             var value = opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, j);

             if ((j < 10 && value !== "" + j) || (j >= 10 && value !== undefined))

                 throw "Failed opaqueGetByValOnStringAndInt32ArrayHotOutOfBounds(stringArray, j) out-of-bounds with j = " + j + " value = " + value;

165 }

166 }

167 }

168 testStringAndInt32ArrayHotOutOfBounds();

169

170

171 // Get out-of-bound data from a hole after a thousand run.

 function opaqueGetByValOnDoubleArrayHotOutOfBounds(array, index)

173 {

174 return array[index];

175 }

176 noInline(opaqueGetByValOnDoubleArrayHotOutOfBounds);

177

178 function testStringArrayHotOutOfBounds()

179 {

180 // Warm up with in bounds access.

     var doubleArray = new Array(10);

     for (var i = 0; i < 10; ++i) {

         if (i !== 5)

             doubleArray[i] = i + 0.5;

185 }

     for (var i = 0; i < 1e2; ++i) {

         for (var j = 0; j < 10; ++j) {

             if (j !== 5) {

                 var value = opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, j);

                 if (value !== j + 0.5)

                     throw "Failed opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, j) in-bounds with j = " + j + " value = " + value;

192 }

193 }

194 }

195

196 // Do a single out of bounds after warmup.

     var value = opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, 5);

     if (value !== undefined)

         throw "Failed opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, 5) with i = " + i + " value = " + value;

200

201 // We then do plenty of in-bounds accesses.

     for (var i = 0; i < 1e3; ++i) {

         for (var j = 0; j < 10; ++j) {

             if (j !== 5) {

                 var value = opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, j);

                 if (value !== j + 0.5)

                     throw "Failed opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, j) in-bounds with j = " + j + " value = " + value;

208 }

209 }

210 }

211

212 // Followed by plenty of out-of-bounds accesses.

     for (var i = 0; i < 1e3; ++i) {

         for (var j = 0; j < 10; ++j) {

             var value = opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, j);

             if ((j !== 5 && value !== j + 0.5) || (j === 10 && value !== undefined))

                 throw "Failed opaqueGetByValOnDoubleArrayHotOutOfBounds(doubleArray, j) out-of-bounds with j = " + j + " value = " + value;

218 }

219 }

220 }

221 testStringArrayHotOutOfBounds();