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

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

     1 // |jit-test| error: Assertion failed: bad label: 2

     2 try {

     3     this['Module'] = Module;

     4 } catch (e) {

     5     this['Module'] = Module = {};

6 }

     7 var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';

     8 var ENVIRONMENT_IS_WEB = typeof window === 'object';

     9 var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';

    10 var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

    11 if (ENVIRONMENT_IS_SHELL) {

    12     Module['print'] = print;

    13     Module['arguments'] = [];

    14 }

    15 var Runtime = {

    16     alignMemory: function alignMemory(size, quantum) {},

    17 }

    18     function SAFE_HEAP_CLEAR(dest) {

    19     }

    20     function SAFE_HEAP_STORE(dest, value, type, ignore) {

    21         setValue(dest, value, type, 1);

    22     }

    23     function SAFE_HEAP_LOAD(dest, type, unsigned, ignore) {

    24 	try { } catch(e) {};

    25         var ret = getValue(dest, type, 1);

    26         return ret;

    27     };

    28     function SAFE_HEAP_LOAD1(dest, type) {

    29 	return getValue(dest, type, 1);

    30     };

    31 function abort(text) {

    32     Module.print(text + ':\n' + (new Error).stack);

    33     throw "Assertion: " + text;

    34 }

    35 function assert(condition, text) {

    36     if (!condition) {

    37         abort('Assertion failed: ' + text);

    38     }

    39 }

    40 function setValue(ptr, value, type, noSafe) {

    41     if (type.charAt(type.length - 1) === '*') type = 'i32'; // pointers are 32-bit

    42     if (noSafe) {

    43         switch (type) {

    44             case 'i32':

    45                 HEAP32[((ptr) >> 2)] = value;

    46         }

    47     }

    48 }

    49 function getValue(ptr, type, noSafe) {

    50     if (type.charAt(type.length - 1) === '*') type = 'i32'; // pointers are 32-bit

    51     if (noSafe) {

    52         switch (type) {

    53             case 'i32':

    54                 return HEAP32[((ptr) >> 2)];

    55         }

    56     }

    57 }

    58 var ALLOC_STATIC = 2; // Cannot be freed

    59 function allocate(slab, types, allocator, ptr) {}

    60 var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216;

    61 var buffer = new ArrayBuffer(TOTAL_MEMORY);

    62 HEAP32 = new Int32Array(buffer);

    63 STACK_ROOT = STACKTOP = Runtime.alignMemory(1);

    64 function intArrayFromString(stringy, dontAddNull, length /* optional */ ) {}

    65 function __ZN11btRigidBody14getMotionStateEv($this_0_20_val) {

    66 }

    67 function __ZN16btCollisionWorld23getCollisionObjectArrayEv($this) {}

    68 function __ZN20btAlignedObjectArrayIP17btCollisionObjectEixEi($this_0_3_val, $n) {}

    69 function _main($argc, $argv) {

    70     label = 2;

    71     while (1) switch (label) {

    72         case 2:

    73             var $31 = __Znwj(268);

    74             var $32 = $31;

    75             var $67 = __ZN17btCollisionObjectnwEj();

    76             var $68 = $67;

    77             __ZN23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBody($32, $68);

    78             var $99 = $31;

    79             var $104 = __ZN23btDiscreteDynamicsWorld14stepSimulationEfif($32, .01666666753590107, 10, .01666666753590107);

    80             var $106 = __ZNK16btCollisionWorld22getNumCollisionObjectsEv($99);

    81             var $108 = __ZN16btCollisionWorld23getCollisionObjectArrayEv($99);

    82             var $_idx6 = $108 + 12 | 0;

    83             var $j_049_in = $106;

    84             var $j_049 = $j_049_in - 1 | 0;

    85             var $_idx6_val = SAFE_HEAP_LOAD($_idx6, "%class.btCollisionObject**", 0, 0);

    86             var $109 = __ZN20btAlignedObjectArrayIP17btCollisionObjectEixEi($_idx6_val, $j_049);

    87             var $110 = SAFE_HEAP_LOAD($109, "%class.btCollisionObject*", 0, 0);

    88             var $111 = __ZN11btRigidBody6upcastEP17btCollisionObject($110);

    89             var $_idx9 = $111 + 472 | 0;

    90             var $_idx9_val = SAFE_HEAP_LOAD($_idx9, "%class.btMotionState*", 0, 0);

    91             var $114 = __ZN11btRigidBody14getMotionStateEv($_idx9_val);

    92             var $138 = $i_057 + 1 | 0;

    93             var $139 = ($138 | 0) < 135;

    94             if ($139) {

    95                 var $i_057 = $138;

    96                 break;

    97             }

    98             assert(0, "bad label: " + label);

    99     }

   100 }

   101 Module["_main"] = _main;

   102 function __ZN17btCollisionObjectnwEj() {

   103     return __Z22btAlignedAllocInternalji(608);

   104 }

   105 function __ZNK16btCollisionWorld22getNumCollisionObjectsEv($this) {}

   106 function __ZN11btRigidBody6upcastEP17btCollisionObject($colObj) {

   107     label = 2;

   108     while (1) switch (label) {

   109         case 2:

   110             var $_0;

   111             return $_0;

   112     }

   113 }

   114 function __ZNK9btVector33dotERKS_($this_0_0_0_val, $this_0_0_1_val, $this_0_0_2_val, $v_0_0_0_val, $v_0_0_1_val, $v_0_0_2_val) {

   115 }

   116 function __ZN20btAlignedObjectArrayIP11btRigidBodyEixEi($this_0_3_val, $n) {}

   117 function __ZNK17btCollisionObject14getHitFractionEv($this_0_21_val) {}

   118 function __ZN17btCollisionObject30getInterpolationWorldTransformEv($this) {}

   119 function __ZNK17btCollisionObject30getInterpolationLinearVelocityEv($this) {}

   120 function __ZNK17btCollisionObject31getInterpolationAngularVelocityEv($this) {}

   121 function __ZN23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody($this, $body) {

   122     assertEq($body, 16);

   123     var __stackBase__ = STACKTOP;

   124     while (1) switch (label) {

   125         case 2:

   126             var $interpolatedTransform = __stackBase__;

   127             var $4 = $body | 0;

   128             var $7 = __ZN17btCollisionObject30getInterpolationWorldTransformEv($4);

   129             var $8 = __ZNK17btCollisionObject30getInterpolationLinearVelocityEv($4);

   130             var $9 = __ZNK17btCollisionObject31getInterpolationAngularVelocityEv($4);

   131             var $10 = $this + 236 | 0;

   132             var $11 = SAFE_HEAP_LOAD($10, "float", 0, 0);

   133             var $_idx2 = $body + 240 | 0;

   134             var $_idx2_val = SAFE_HEAP_LOAD($_idx2, "float", 0, 0);

   135             var $12 = __ZNK17btCollisionObject14getHitFractionEv($_idx2_val);

   136             var $13 = $11 * $12;

   137             var $_idx3 = $8 | 0;

   138             var $_idx3_val = SAFE_HEAP_LOAD($_idx3, "float", 0, 0);

   139             var $_idx4 = $8 + 4 | 0;

   140             var $_idx4_val = SAFE_HEAP_LOAD($_idx4, "float", 0, 0);

   141             var $_idx5 = $8 + 8 | 0;

   142             var $_idx5_val = SAFE_HEAP_LOAD($_idx5, "float", 0, 0);

   143             __ZN15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5_fRS0_($7, $_idx3_val, $_idx4_val, $_idx5_val, $9, $13, $interpolatedTransform);

   144             return;

   145     }

   146 }

   147 function __ZN15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5_fRS0_($curTrans, $linvel_0_0_0_val, $linvel_0_0_1_val, $linvel_0_0_2_val, $angvel, $timeStep, $predictedTransform) {

   148     var __stackBase__ = STACKTOP;

   149     STACKTOP = STACKTOP + 132 | 0;

   150     while (1) {

   151 	switch (label) {

   152         case 2:

   153             var $axis = __stackBase__ + 32;

   154             var $3 = __stackBase__ + 48;

   155             var $angvel_idx10 = $angvel | 0;

   156             var $angvel_idx10_val = SAFE_HEAP_LOAD($angvel_idx10, "float", 0, 0);

   157 	    var $angvel_idx11 = $angvel + 4 | 0;

   158             var $angvel_idx11_val = SAFE_HEAP_LOAD($angvel_idx11, "float", 0, 0);

   159             var $angvel_idx12 = $angvel + 8 | 0;

   160             var $angvel_idx12_val = SAFE_HEAP_LOAD($angvel_idx12, "float", 0, 0);

   161             var $7 = __ZNK9btVector36lengthEv($angvel_idx10_val, $angvel_idx11_val, $angvel_idx12_val);

   162             var $8 = $7 * $timeStep;

   163             if ($8 > .7853981852531433) {} else {

   164                 var $fAngle_0 = $7;

   165                 label = 5;

   166             }

   167 	    break;

   168         case 5:

   169             var $22 = $axis;

   170             var $23 = $3;

   171             SAFE_HEAP_STORE($22 + 12, SAFE_HEAP_LOAD1($23 + 12, "i32"), "i32", 0);

   172 	    assertEq(SAFE_HEAP_LOAD1(0, "%class.btRigidBody*"), 16);

   173             label = 7;

   174             break;

   175         case 6:

   176             SAFE_HEAP_STORE($29 + 12, SAFE_HEAP_LOAD1($30 + 12, "i32"), "i32", 0);

   177         case 7:

   178             for (var i = __stackBase__; i < STACKTOP; i++) SAFE_HEAP_CLEAR(i);

   179             return;

   180 	}

   181     }

   182 }

   183 function __ZN23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBody($this, $body) {

   184     SAFE_HEAP_STORE(STACKTOP, $body, "%class.btRigidBody*", 0);

   185     assertEq(SAFE_HEAP_LOAD(0, "%class.btRigidBody*", 0, 0), 16);

   186 }

   187 function __ZN23btDiscreteDynamicsWorld23synchronizeMotionStatesEv($this) {

   188     var $20 = SAFE_HEAP_LOAD(0, "%class.btRigidBody*", 0, 0);

   189     assertEq($20, 16);

   190     __ZN23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody($this, $20);

   191 }

   192 function __ZN23btDiscreteDynamicsWorld14stepSimulationEfif($this, $timeStep, $maxSubSteps, $fixedTimeStep) {

   193     label = 2;

   194     while (1) switch (label) {

   195         case 2:

   196             var $numSimulationSubSteps_0;

   197             __ZN23btDiscreteDynamicsWorld23synchronizeMotionStatesEv($this);

   198             return $numSimulationSubSteps_0;

   199     }

   200 }

   201 function __ZNK9btVector37length2Ev($this_0_0_0_val, $this_0_0_1_val, $this_0_0_2_val) {

   202     return __ZNK9btVector33dotERKS_($this_0_0_0_val, $this_0_0_1_val, $this_0_0_2_val, $this_0_0_0_val, $this_0_0_1_val, $this_0_0_2_val);

   203 }

   204 function __Z6btSqrtf($y) {

   205     return Math.sqrt($y);

   206 }

   207 function __ZNK9btVector36lengthEv($this_0_0_0_val, $this_0_0_1_val, $this_0_0_2_val) {

   208     return __Z6btSqrtf(__ZNK9btVector37length2Ev($this_0_0_0_val, $this_0_0_1_val, $this_0_0_2_val));

   209 }

   210 function __ZL21btAlignedAllocDefaultji($size, $alignment) {

   211     while (1) switch (label) {

   212         case 2:

   213             var $1 = $size + 4 | 0;

   214             var $2 = $alignment - 1 | 0;

   215             var $3 = $1 + $2 | 0;

   216             var $4 = __ZL14btAllocDefaultj($3);

   217             var $7 = $4 + 4 | 0;

   218             var $8 = $7;

   219             var $9 = $alignment - $8 | 0;

   220             var $10 = $9 & $2;

   221             var $_sum = $10 + 4 | 0;

   222             var $11 = $4 + $_sum | 0;

   223             var $ret_0 = $11;

   224             return $ret_0;

   225     }

   226 }

   227 function __ZL14btAllocDefaultj($size) {

   228     return _malloc($size);

   229 }

   230 function __Z22btAlignedAllocInternalji($size) {

   231     return __ZL21btAlignedAllocDefaultji($size, 16);

   232 }

   233 function _malloc($bytes) {

   234     while (1) switch (label) {

   235         case 2:

   236             var $189 = SAFE_HEAP_LOAD(5244020, "%struct.malloc_chunk*", 0, 0);

   237             var $198 = $189 + 8 | 0;

   238             var $199 = $198;

   239             var $mem_0 = $199;

   240             return $mem_0;

   241     }

   242 }

   243 function __Znwj($size) {

   244     while (1) switch (label) {

   245         case 2:

   246             var $1 = ($size | 0) == 0;

   247             var $_size = $1 ? 1 : $size;

   248             var $3 = _malloc($_size);

   249             return $3;

   250     }

   251 }

   252 Module.callMain = function callMain(args) {

   253     var argc = args.length + 1;

   254     var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC)];

   255     return Module['_main'](argc, argv, 0);

   256 }

   257 function run(args) {

   258     args = args || Module['arguments'];

   259     function doRun() {

   260         if (Module['_main']) {

   261             ret = Module.callMain(args);

   262         }

   263     }

   264     if (Module['setStatus']) {} else {

   265         return doRun();

   266     }

   267 }

   268 run();

The Tor Browser / file revision

js/src/jit-test/tests/bug830943.js@6474c204b198

js/src/jit-test/tests/bug830943.js