The Tor Browser: js/src/jit-test/tests/asm.js/testSource.js@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 setCachingEnabled(true);

     3 (function() {

     4 /*

     5  * NO ARGUMENT

     6  */

     8 function f0() {

     9     "use asm";

    10     function g() {}

    11     return g;

    13 }

    15 var bodyOnly = '"use asm";\n\

    16     function g() {}\n\

    17     return g;\n';

    19 var funcBody =  'function f0() {\n\

    20     "use asm";\n\

    21     function g() {}\n\

    22     return g;\n\n\

    23 }';

    25 assertEq(f0.toString(), funcBody);

    26 assertEq(f0.toSource(), funcBody);

    28 var f0 = function() {

    29     "use asm";

    30     function g() {}

    31     return g;

    33 }

    35 funcBody1 = funcBody.replace('function f0','function ');

    36 assertEq(f0.toString(), funcBody1);

    37 assertEq(f0.toSource(), '(' + funcBody1 + ')');

    39 var g = function g0() {

    40     "use asm";

    41     function g() {}

    42     return g;

    44 }

    46 funcBody2 = funcBody.replace('function f0', 'function g0');

    47 assertEq(g.toString(), funcBody2);

    48 assertEq(g.toSource(), '(' + funcBody2 + ')');

    50 f0 = new Function(bodyOnly);

    51 assertEq(f0.toString(), "function anonymous() {\n" + bodyOnly + "\n}");

    52 assertEq(f0.toSource(), "(function anonymous() {\n" + bodyOnly + "\n})");

    54 if (isAsmJSCompilationAvailable() && isCachingEnabled()) {

    55     var m = new Function(bodyOnly);

    56     assertEq(isAsmJSModuleLoadedFromCache(m), true);

    57     assertEq(m.toString(), "function anonymous() {\n" + bodyOnly + "\n}");

    58     assertEq(m.toSource(), "(function anonymous() {\n" + bodyOnly + "\n})");

    59 }

    61 })();

    63 (function() {

    64 /*

    65  * ONE ARGUMENT

    66  */

    67 function f1(glob) {

    68     "use asm";

    69     function g() {}

    70     return g;

    72 }

    74 var bodyOnly = '"use asm";\n\

    75     function g() {}\n\

    76     return g;\n';

    78 var funcBody =  'function f1(glob) {\n\

    79     "use asm";\n\

    80     function g() {}\n\

    81     return g;\n\n\

    82 }';

    84 assertEq(f1.toString(), funcBody);

    85 assertEq(f1.toSource(), funcBody);

    87 f1 = function(glob) {

    88     "use asm";

    89     function g() {}

    90     return g;

    92 }

    94 funcBody1 = funcBody.replace('function f1', 'function ');

    95 assertEq(f1.toString(), funcBody1);

    96 assertEq(f1.toSource(), '(' + funcBody1 + ')');

    98 var g = function g0(glob) {

    99     "use asm";

   100     function g() {}

   101     return g;

   103 }

   105 funcBody2 = funcBody.replace('function f1', 'function g0');

   106 assertEq(g.toString(), funcBody2);

   107 assertEq(g.toSource(), '(' + funcBody2 + ')');

   109 f1 = new Function('glob', bodyOnly);

   110 assertEq(f1.toString(), "function anonymous(glob) {\n" + bodyOnly + "\n}");

   111 assertEq(f1.toSource(), "(function anonymous(glob) {\n" + bodyOnly + "\n})");

   113 if (isAsmJSCompilationAvailable() && isCachingEnabled()) {

   114     var m = new Function('glob', bodyOnly);

   115     assertEq(isAsmJSModuleLoadedFromCache(m), true);

   116     assertEq(m.toString(), "function anonymous(glob) {\n" + bodyOnly + "\n}");

   117     assertEq(m.toSource(), "(function anonymous(glob) {\n" + bodyOnly + "\n})");

   118 }

   120 })();

   123 (function() {

   124 /*

   125  * TWO ARGUMENTS

   126  */

   127 function f2(glob, ffi) {

   128     "use asm";

   129     function g() {}

   130     return g;

   132 }

   134 var bodyOnly = '"use asm";\n\

   135     function g() {}\n\

   136     return g;\n';

   138 var funcBody =  'function f2(glob, ffi) {\n\

   139     "use asm";\n\

   140     function g() {}\n\

   141     return g;\n\n\

   142 }';

   144 assertEq(f2.toString(), funcBody);

   145 assertEq(f2.toSource(), funcBody);

   147 f2 = function (glob, ffi) {

   148     "use asm";

   149     function g() {}

   150     return g;

   152 }

   154 funcBody1 = funcBody.replace('function f2', 'function ');

   155 assertEq(f2.toString(), funcBody1);

   156 assertEq(f2.toSource(), '(' + funcBody1 + ')');

   158 var g = function g0(glob, ffi) {

   159     "use asm";

   160     function g() {}

   161     return g;

   163 }

   165 var funcBody2 = funcBody.replace('function f2', 'function g0');

   166 assertEq(g.toString(), funcBody2);

   167 assertEq(g.toSource(), '(' + funcBody2 + ')');

   169 f2 = new Function('glob', 'ffi', bodyOnly);

   170 assertEq(f2.toString(), "function anonymous(glob, ffi) {\n" + bodyOnly + "\n}");

   171 assertEq(f2.toSource(), "(function anonymous(glob, ffi) {\n" + bodyOnly + "\n})");

   173 if (isAsmJSCompilationAvailable() && isCachingEnabled()) {

   174     var m = new Function('glob', 'ffi', bodyOnly);

   175     assertEq(isAsmJSModuleLoadedFromCache(m), true);

   176     assertEq(m.toString(), "function anonymous(glob, ffi) {\n" + bodyOnly + "\n}");

   177     assertEq(m.toSource(), "(function anonymous(glob, ffi) {\n" + bodyOnly + "\n})");

   178 }

   180 })();

   183 (function() {

   184 /*

   185  * THREE ARGUMENTS

   186  */

   187 function f3(glob, ffi, heap) {

   188     "use asm";

   189     function g() {}

   190     return g;

   192 }

   194 var bodyOnly = '"use asm";\n\

   195     function g() {}\n\

   196     return g;\n';

   198 var funcBody =  'function f3(glob, ffi, heap) {\n\

   199     "use asm";\n\

   200     function g() {}\n\

   201     return g;\n\n\

   202 }';

   204 assertEq(f3.toString(), funcBody);

   205 assertEq(f3.toSource(), funcBody);

   207 f3 = function (glob, ffi, heap) {

   208     "use asm";

   209     function g() {}

   210     return g;

   212 }

   214 funcBody1 = funcBody.replace('function f3', 'function ');

   215 assertEq(f3.toString(), funcBody1);

   216 assertEq(f3.toSource(), '(' + funcBody1 + ')');

   218 var g = function g0(glob, ffi, heap) {

   219     "use asm";

   220     function g() {}

   221     return g;

   223 }

   225 funcBody2 = funcBody.replace('function f3', 'function g0');

   226 assertEq(g.toString(), funcBody2);

   227 assertEq(g.toSource(), '(' + funcBody2 + ')');

   229 f3 = new Function('glob', 'ffi', 'heap', bodyOnly);

   230 assertEq(f3.toString(), "function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n}");

   231 assertEq(f3.toSource(), "(function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n})");

   233 if (isAsmJSCompilationAvailable() && isCachingEnabled()) {

   234     var m = new Function('glob', 'ffi', 'heap', bodyOnly);

   235     assertEq(isAsmJSModuleLoadedFromCache(m), true);

   236     assertEq(m.toString(), "function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n}");

   237     assertEq(m.toSource(), "(function anonymous(glob, ffi, heap) {\n" + bodyOnly + "\n})");

   238 }

   240 })();

   242 /* Implicit "use strict" context */

   243 (function() {

   245 var funcHeader =  'function (glob, ffi, heap) {',

   246     funcBody = '\n"use asm";\n\

   247     function g() {}\n\

   248     return g;\n\n'

   249     funcFooter = '}',

   250     funcSource = funcHeader + funcBody + funcFooter

   251     useStrict = '\n"use strict";\n';

   253 var f4 = eval("\"use strict\";\n(" + funcSource + ")");

   255 var expectedToString = funcHeader + useStrict + funcBody + funcFooter

   256 var expectedToSource = '(' + expectedToString + ')'

   258 assertEq(f4.toString(), expectedToString);

   259 assertEq(f4.toSource(), expectedToSource);

   261 if (isAsmJSCompilationAvailable() && isCachingEnabled()) {

   262     var f5 = eval("\"use strict\";\n(" + funcSource + ")");

   263     assertEq(isAsmJSModuleLoadedFromCache(f5), true);

   264     assertEq(f5.toString(), expectedToString);

   265     assertEq(f5.toSource(), expectedToSource);

   266 }

   267 })();

   269 /* Functions */

   270 (function() {

   272 var noSrc = "function noArgument() {\n\

   273     return 42;\n\

   274 }"

   275 var oneSrc = "function oneArgument(x) {\n\

   276     x = x | 0;\n\

   277     return x + 1 | 0;\n\

   278 }";

   279 var twoSrc = "function twoArguments(x, y) {\n\

   280     x = x | 0;\n\

   281     y = y | 0;\n\

   282     return x + y | 0;\n\

   283 }";

   284 var threeSrc = "function threeArguments(a, b, c) {\n\

   285     a = +a;\n\

   286     b = +b;\n\

   287     c = +c;\n\

   288     return +(+(a * b) + c);\n\

   289 }";

   291 var funcBody = '\n\

   292     "use asm";\n'

   293     + noSrc + '\n'

   294     + oneSrc + '\n'

   295     + twoSrc + '\n'

   296     + threeSrc + '\n'

   297     + 'return {\n\

   298     no: noArgument,\n\

   299     one: oneArgument,\n\

   300     two: twoArguments,\n\

   301     three: threeArguments\n\

   302     }';

   304 var g = new Function(funcBody);

   305 var moduleG = g();

   307 function checkFuncSrc(m) {

   308     assertEq(m.no.toString(), noSrc);

   309     assertEq(m.no.toSource(), noSrc);

   311     assertEq(m.one.toString(), oneSrc);

   312     assertEq(m.one.toSource(), oneSrc);

   314     assertEq(m.two.toString(), twoSrc);

   315     assertEq(m.two.toSource(), twoSrc);

   317     assertEq(m.three.toString(), threeSrc);

   318     assertEq(m.three.toSource(), threeSrc);

   319 }

   320 checkFuncSrc(moduleG);

   322 if (isAsmJSCompilationAvailable() && isCachingEnabled()) {

   323     var g2 = new Function(funcBody);

   324     assertEq(isAsmJSModuleLoadedFromCache(g2), true);

   325     m = g2();

   326     checkFuncSrc(m);

   328     var moduleDecl = 'function g3() {' + funcBody + '}';

   329     eval(moduleDecl);

   330     m = g3();

   331     assertEq(isAsmJSModuleLoadedFromCache(g3), false);

   332     checkFuncSrc(m);

   334     eval('var x = 42;' + moduleDecl);

   335     m = g3();

   336     assertEq(isAsmJSModuleLoadedFromCache(g3), true);

   337     checkFuncSrc(m);

   338 }

   340 })();

The Tor Browser / file revision

js/src/jit-test/tests/asm.js/testSource.js@6474c204b198

js/src/jit-test/tests/asm.js/testSource.js