├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE └── README.md /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Contributor Code of Conduct 2 | 3 | As contributors and maintainers of this project, and in the interest of 4 | fostering an open and welcoming community, we pledge to respect all people who 5 | contribute through reporting issues, posting feature requests, updating 6 | documentation, submitting pull requests or patches, and other activities. 7 | 8 | We are committed to making participation in this project a harassment-free 9 | experience for everyone, regardless of level of experience, gender, gender 10 | identity and expression, sexual orientation, disability, personal appearance, 11 | body size, race, ethnicity, age, religion, or nationality. 12 | 13 | Examples of unacceptable behavior by participants include: 14 | 15 | * The use of sexualized language or imagery 16 | * Personal attacks 17 | * Trolling or insulting/derogatory comments 18 | * Public or private harassment 19 | * Publishing other's private information, such as physical or electronic 20 | addresses, without explicit permission 21 | * Other unethical or unprofessional conduct 22 | 23 | Project maintainers have the right and responsibility to remove, edit, or 24 | reject comments, commits, code, wiki edits, issues, and other contributions 25 | that are not aligned to this Code of Conduct, or to ban temporarily or 26 | permanently any contributor for other behaviors that they deem inappropriate, 27 | threatening, offensive, or harmful. 28 | 29 | By adopting this Code of Conduct, project maintainers commit themselves to 30 | fairly and consistently applying these principles to every aspect of managing 31 | this project. Project maintainers who do not follow or enforce the Code of 32 | Conduct may be permanently removed from the project team. 33 | 34 | This code of conduct applies both within project spaces and in public spaces 35 | when an individual is representing the project or its community. 36 | 37 | Instances of abusive, harassing, or otherwise unacceptable behavior may be 38 | reported by contacting a project maintainer at victorfelder at gmail.com. All 39 | complaints will be reviewed and investigated and will result in a response that 40 | is deemed necessary and appropriate to the circumstances. Maintainers are 41 | obligated to maintain confidentiality with regard to the reporter of an 42 | incident. 43 | 44 | 45 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], 46 | version 1.3.0, available at 47 | [http://contributor-covenant.org/version/1/3/0/][version] 48 | 49 | [homepage]: http://contributor-covenant.org 50 | [version]: http://contributor-covenant.org/version/1/3/0/ 51 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | ## Contributor Code of Conduct 2 | 3 | By contributing you agree to respect the [Code of Conduct](/CODE_OF_CONDUCT.md) of this repository. 4 | 5 | ### Guidelines 6 | 7 | * (Open an issue or...) 8 | * Fork this repo and submit a pull request 9 | * Use the provided [template](#template) 10 | * Insert the bailout reasons in alphabetical order 11 | * When adding a new bailout reasons 12 | 1. Update the index 13 | 2. Cross it from the list at the end of the file 14 | * Remember to attribute the work to its author (for example when the explaination isn't yours) 15 | 16 | 17 | ### Template 18 | 19 | (Use the following template to add a bailout reason.) 20 | 21 | ### This is a bailout reason 22 | 23 | (optional explanation) 24 | 25 | * Simple reproduction(s) 26 | 27 | ```js 28 | // strict & sloppy modes OR // sloppy mode only 29 | ... 30 | ``` 31 | 32 | * Why 33 | * Some explanation (if you have one) 34 | 35 | * Advices 36 | * Some advices (if you have any) 37 | 38 | * External examples 39 | * [example](http://example.com) where this deopt has/had impact 40 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 victor felder 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # V8 bailout reasons 2 | 3 | A list of Crankshaft bailout reasons with examples, explanations and advices. 4 | 5 | Unless otherwise specified, the following are Crankshaft bailouts. 6 | 7 | ### Warning! 8 | 9 | Starting from Chrome 59 and [Node.js 8.3.0](https://medium.com/the-node-js-collection/node-js-8-3-0-is-now-available-shipping-with-the-ignition-turbofan-execution-pipeline-aa5875ad3367), **Crankshaft is not used anymore**. It uses [TurboFan](https://github.com/v8/v8/wiki/TurboFan) instead. 10 | 11 | **The content of this repository only applies to Crankshaft**. If the JavaScript engine you are targeting does not use Crankshaft as its optimizing compiler, you should not care about this repository and the advices present in there. This repository will stay here for historical reasons, it still has documentation value. 12 | 13 | ### What this is about 14 | 15 | In order to keep this section short and allow people to get to the primary content of this repo faster, here is what it's all about and why you (probably) should care if you are using Crankshaft: [Chromium, Chrome, Node.js, V8, Crankshaft and bailout reasons](https://draft.li/blog/2016/01/22/chromium-chrome-v8-crankshaft-bailout-reasons/). 16 | 17 | ## Index 18 | ### [Bailout reasons](#bailout-reasons-1) 19 | 20 | * [Assignment to parameter in arguments object](#assignment-to-parameter-in-arguments-object) 21 | * [Bad value context for arguments value](#bad-value-context-for-arguments-value) 22 | * [ForInStatement with non-local each variable](#forinstatement-with-non-local-each-variable) 23 | * [Inlining bailed out](#inlining-bailed-out) 24 | * [Object literal with complex property](#object-literal-with-complex-property) 25 | * [Optimized too many times](#optimized-too-many-times) 26 | * [Reference to a variable which requires dynamic lookup](#reference-to-a-variable-which-requires-dynamic-lookup) 27 | * [Rest parameters](#rest-parameters) 28 | * [Smi addition overflow](#smi-addition-overflow) 29 | * [Smi subtraction overflow](#smi-subtraction-overflow) 30 | * [Too many parameters](#too-many-parameters) 31 | * [TryCatchStatement](#trycatchstatement) 32 | * [TryFinallyStatement](#tryfinallystatement) 33 | * [Unsupported phi use of arguments](#unsupported-phi-use-of-arguments) 34 | * [Unsupported phi use of const or let variable](#unsupported-phi-use-of-const-or-let-variable) 35 | * [Yield](#yield) 36 | 37 | ### [References](#references-1) 38 | 39 | * [Resources](#resources) 40 | * [All bailout reasons](#all-bailout-reasons) 41 | 42 | 43 | ## Bailout reasons 44 | ### Assignment to parameter in arguments object 45 | 46 | Only happens if you reassign to a parameter while also mentioning `arguments` in the function. [More info](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#31-reassigning-a-defined-parameter-while-also-mentioning-arguments-in-the-body-in-sloppy-mode-only-typical-example). 47 | 48 | * Simple reproduction(s) 49 | 50 | ```js 51 | // sloppy mode only 52 | function test(a) { 53 | if (arguments.length < 2) { 54 | a = 0; 55 | } 56 | } 57 | ``` 58 | 59 | * Why 60 | * In sloppy mode V8 needs to preserve bindings between `arguments[0]` and `a` so that when any `a` was passed, and you reassign it to `10`, and later try to read `arguments[0]`, it has to return `10`, too. This is non-trivial for the engine, so it chooses to bail out. Strict mode removes this requirement, and `arguments` and `a` behave as regular independent JavaScript variables, so deoptimization does not occur. 61 | 62 | * Advices 63 | * In the above example, you could assign `a` to a new variable. 64 | * You should use strict mode anyway. 65 | * It seems this will be optimized by TurboFan [#1][1]. 66 | 67 | * External examples 68 | 69 | 70 | ### Bad value context for arguments value 71 | 72 | * Simple reproduction(s) 73 | 74 | ```js 75 | // strict & sloppy modes 76 | function test1() { 77 | arguments[0] = 0; 78 | } 79 | 80 | // strict & sloppy modes 81 | function test2() { 82 | arguments.length = 0; 83 | } 84 | 85 | // strict & sloppy modes 86 | function test3() { 87 | return arguments; 88 | } 89 | 90 | // strict & sloppy modes 91 | function test4() { 92 | var args = [].slice.call(arguments); 93 | } 94 | 95 | // strict & sloppy modes 96 | function test5() { 97 | var a = arguments; 98 | return function() { 99 | return a; 100 | }; 101 | } 102 | ``` 103 | 104 | * Why 105 | * It requires rematerialization of the `arguments` array. 106 | 107 | * Advices 108 | * Read this: https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments 109 | * You could loop over `arguments` to build a new array, but it's not recommended. See [Unsupported phi use of arguments](#unsupported-phi-use-of-arguments) 110 | * Usages of `arguments` as shown above are very rarely legitimate. 111 | * [More about this bailout reason][7] 112 | * It seems this will be optimized by TurboFan [#1][1]. 113 | 114 | * External examples 115 | * https://github.com/bevry/taskgroup/issues/12 116 | * https://github.com/babel/babel/pull/3249 117 | 118 | 119 | ### ForInStatement with non-local each variable 120 | 121 | * Simple reproduction(s) 122 | 123 | ```js 124 | // strict & sloppy modes 125 | function test1() { 126 | var obj = {}; 127 | for(key in obj); 128 | } 129 | 130 | // strict & sloppy modes 131 | function key() { 132 | return 'a'; 133 | } 134 | function test2() { 135 | var obj = {}; 136 | for(key in obj); 137 | } 138 | ``` 139 | 140 | * Why 141 | 142 | * Advices 143 | * Only use pure (i.e. non-computed) local variable in a for...in. 144 | * https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#5-for-in 145 | 146 | * External examples 147 | * https://github.com/mbostock/d3/pull/2686 148 | 149 | 150 | ### Inlining bailed out 151 | 152 | * Simple reproduction(s) 153 | 154 | [Courtesy of @kangax](https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-32784608) 155 | 156 | ```js 157 | // strict & sloppy modes 158 | var obj = { prop1: ... }; 159 | 160 | function test(param) { 161 | param.prop2 = ...; // Inlining bailed out 162 | } 163 | test(obj); 164 | 165 | // strict & sloppy modes 166 | var obj = { prop1: ... }; 167 | 168 | function someMethodThatAssignsSomeOtherProp(param) { 169 | param.someOtherProp = ...; // Inlining bailed out 170 | } 171 | 172 | function test(param) { 173 | someMethodThatAssignsSomeOtherProp(param); 174 | } 175 | 176 | f(obj); 177 | ``` 178 | 179 | * Why 180 | * Crankshaft predicts that `param` will have the same hidden class as `obj`, allowing optimization by doing inline caching. At the annotated lines above, Crankshaft notices that `obj`'s hidden class is not suitable for `param` and bails out (it cannot patch the inline cache code with the hidden class information). [More about inline caching and hidden classes][8] 181 | 182 | * Advices 183 | * When creating an object initialize all the properties you are going to use, instead of adding new properties to an existing object. 184 | 185 | * External examples 186 | 187 | 188 | ### Object literal with complex property 189 | 190 | * Simple reproduction(s) 191 | 192 | ```js 193 | // strict & sloppy modes 194 | function test() { 195 | return { 196 | __proto__: 3 197 | }; 198 | } 199 | ``` 200 | 201 | * Why 202 | 203 | * Advices 204 | 205 | * External examples 206 | 207 | 208 | ### Optimized too many times 209 | 210 | * Simple reproduction(s) 211 | 212 | ```js 213 | // strict & sloppy modes 214 | // No known canonical reproduction 215 | ``` 216 | 217 | * Why 218 | * Optimization failed so many times that Crankshaft gave up. 219 | * "In reality this very often actually means a bug in V8 - there is some optimization which is too optimistic so the generated code deopts all the time." - @mraleph [#5][5] 220 | * [More about this bailout reason][6] 221 | 222 | * Advices 223 | * "Just use IRHydra and look at the deoptimization reasons - the picture should become clear immediately." - @mraleph [#5][5] 224 | 225 | * External examples 226 | 227 | 228 | ### Reference to a variable which requires dynamic lookup 229 | 230 | * Simple reproduction(s) 231 | 232 | ```js 233 | // sloppy mode only 234 | function test() { 235 | with ({x:1}) { 236 | return x; 237 | } 238 | } 239 | ``` 240 | 241 | * Why 242 | * "Variable lookup fails at compile time, Crankshaft needs to resort to dynamic lookup at runtime." - Yang Guo [#3][3] 243 | 244 | * Advices 245 | * "Refactor to remove the dependency on runtime-information to resolve the lookup." - Paul Irish [#4][4] 246 | * **No bailout with TurboFan.** 247 | 248 | * External examples 249 | 250 | 251 | ### Rest parameters 252 | 253 | * Simple reproduction(s) 254 | 255 | ```js 256 | // strict & sloppy modes 257 | function test(...rest) { 258 | return rest[0]; 259 | } 260 | ``` 261 | 262 | * Why 263 | * Probably because it requires materializing the `arguments` array. 264 | 265 | * Advices 266 | * Avoid rest parameters or use Babel's [transform-es2015-parameters](http://babeljs.io/docs/plugins/transform-es2015-parameters/) until TurboFan is able to optimize them [#1][1], [#2][2]. 267 | 268 | * External examples 269 | 270 | ### Smi addition overflow 271 | * Simple reproduction(s) 272 | Smi - A Smi is a 32-bit signed int on 64-bit architectures and a 31-bit signed int on 32-bit architectures. 273 | 274 | Smi addition overflow 275 | ```js 276 | function add(a, b) { 277 | return a + b; 278 | } 279 | 280 | add(1, 2); 281 | add(1, 2); 282 | %OptimizeFunctionOnNextCall(add); 283 | add(2 ** 31 - 2, 20); 284 | ``` 285 | 286 | * Why 287 | * Once addition is performed, the return value cannot be represented as a Smi and thus is casted to [HeapNumber](https://github.com/v8/v8/blob/master/src/objects.h#L1838) 288 | * Advices 289 | * You could have 2 separate functions - one for Smis and one for HeapNumbers. 290 | * External examples 291 | 292 | ### Smi subtraction overflow 293 | * Simple reproduction(s) 294 | Same case as with Smi addition overflow 295 | Smi addition overflow 296 | ```js 297 | function subtract(a, b) { 298 | return a - b; 299 | } 300 | 301 | subtract(1, 2); 302 | subtract(1, 2); 303 | %OptimizeFunctionOnNextCall(subtract); 304 | subtract(-3, 2 ** 31 - 1); 305 | ``` 306 | 307 | * Why 308 | * Once subtraction is performed, the return value cannot be represented as a Smi and thus is casted to [HeapNumber](https://github.com/v8/v8/blob/master/src/objects.h#L1838) 309 | * Advices 310 | * You could have 2 separate functions - one for Smis and one for HeapNumbers. 311 | * External examples 312 | 313 | ### Too many parameters 314 | 315 | * Simple reproduction(s) 316 | 317 | ```js 318 | // strict & sloppy modes 319 | function test(p1, p2, p3, ..., p512) { 320 | } 321 | ``` 322 | 323 | * Why 324 | * Setting limits. 325 | 326 | * Advices 327 | * If you write functions with 512 parameters or more, you probably don't worry about optimizing your code for V8 anyway. 328 | 329 | * External examples 330 | * Obviously nobody ever did that. Hopefully nobody will ever do that. Zero google result on this bailout reason. 331 | * [V8 code source](https://chromium.googlesource.com/v8/v8/+/fe0fe20e8f094d5688256583abc5695243c6759d%5E%21/#F2) 332 | 333 | 334 | ### TryCatchStatement 335 | 336 | * Simple reproduction(s) 337 | 338 | ```js 339 | // strict & sloppy modes 340 | function test() { 341 | return 3; 342 | try {} catch(e) {} 343 | } 344 | ``` 345 | 346 | * Why 347 | * Try/catch makes the control flow jump virtually anywhere. It's hardly optimizable because the caught exception is potentially only known at runtime. 348 | 349 | * Advices 350 | * Don't put try/catch inside computationally intensive functions. 351 | * You could `try { test() } catch` 352 | 353 | * External examples 354 | 355 | 356 | ### TryFinallyStatement 357 | 358 | * Simple reproduction(s) 359 | 360 | ```js 361 | // strict & sloppy modes 362 | function test() { 363 | return 3; 364 | try {} finally {} 365 | } 366 | ``` 367 | 368 | * Why 369 | * See [TryCatchStatement](#trycatchstatement) 370 | 371 | * Advices 372 | * See [TryCatchStatement](#trycatchstatement) 373 | 374 | * External example 375 | 376 | 377 | ### Unsupported phi use of arguments 378 | 379 | * Simple reproduction(s) 380 | 381 | ```js 382 | // strict & sloppy modes 383 | function test1() { 384 | var _arguments = arguments; 385 | if (0 === 0) { // anything evaluating to true, except a number or `true` 386 | _arguments = [0]; // Unsupported phi use of arguments 387 | } 388 | } 389 | 390 | // strict & sloppy modes 391 | function test2() { 392 | var _arguments = arguments; 393 | for (var i = 0; i < 1; i++) { 394 | _arguments = [0]; // Unsupported phi use of arguments 395 | } 396 | } 397 | 398 | // strict & sloppy modes 399 | function test3() { 400 | var _arguments = arguments; 401 | var again = true; 402 | while (again) { 403 | _arguments = [0]; // Unsupported phi use of arguments 404 | again = false; 405 | } 406 | } 407 | ``` 408 | 409 | * Why 410 | * Crankshaft is unable to guess whether `_arguments` should be an object or an array. It cannot dematerialize `_arguments` and gives up. 411 | * [In-depth explaination](http://mrale.ph/blog/2015/11/02/crankshaft-vs-arguments-object.html) 412 | 413 | * Advices 414 | * There is no good workaround except splitting your function into smaller ones that don't manipulate a copy of `arguments`. 415 | * Don't try to fool V8 by looping over `arguments` to create a new array out of it: "Allocating array (and hope it will get handled by some optimization pass in the V8) is a bad idea." - [@mraleph](https://github.com/mraleph) ([source](https://draft.li/blog/2015/11/02/javascript-performance-with-babel-and-node-js/)) 416 | * It seems this will be optimized by TurboFan [#1][1]. 417 | 418 | * External examples 419 | 420 | 421 | ### Unsupported phi use of const or let variable 422 | 423 | * Simple reproduction(s) 424 | 425 | ```js 426 | function test() { 427 | for (let i = 0; i < 0; i++) { 428 | const x = __lookupGetter__; // `__lookupGetter__` and 429 | } 430 | const self = this; // `this` should both be present for this to happen 431 | } 432 | ``` 433 | 434 | * Why 435 | * Crankshaft sees a hole (marker for Temporary Dead Zone of `let`/`const`) and aborts compilation. 436 | 437 | * Advices 438 | 439 | * External examples 440 | 441 | 442 | ### Yield 443 | 444 | * Simple reproduction(s) 445 | 446 | ```js 447 | // strict & sloppy modes 448 | function* test() { 449 | yield 0; 450 | } 451 | ``` 452 | 453 | * Why 454 | 455 | * Advices 456 | 457 | * External examples 458 | 459 | --- 460 | 461 | [1]: https://chromium.googlesource.com/v8/v8/+/d3f074b23195a2426d14298dca30c4cf9183f203%5E%21/src/bailout-reason.h 462 | [2]: https://codereview.chromium.org/1272673003 463 | [3]: https://groups.google.com/forum/#!msg/google-chrome-developer-tools/Y0J2XQ9iiqU/H60qqZNlQa8J 464 | [4]: https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-37269998 465 | [5]: https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-140030617 466 | [6]: https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-145192013 467 | [7]: https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-147569505 468 | [8]: https://developers.google.com/v8/design 469 | 470 | 471 | ## References 472 | ### Resources 473 | 474 | * [All bailout reasons in Chromium codebase](https://code.google.com/p/chromium/codesearch#chromium/src/v8/src/bailout-reason.h) 475 | * [Bad value context for arguments value](https://gist.github.com/Hypercubed/89808f3051101a1a97f3) 476 | * [I-want-to-optimize-my-JS-application-on-V8 checklist](http://mrale.ph/blog/2011/12/18/v8-optimization-checklist.html) 477 | * [JavaScript: Performance loss on incorrect arguments using](http://techblog.dorogin.com/2015/05/performance-loss-on-incorrect-arguments-using.html) 478 | * [Optimization killers](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers) 479 | * [OptimizationKillers](https://github.com/zhangchiqing/OptimizationKillers) 480 | * [Performance Tips for JavaScript in V8](http://www.html5rocks.com/en/tutorials/speed/v8/) 481 | * [thlorenz/v8-perf](https://github.com/thlorenz/v8-perf/blob/master/compiler.md) 482 | * [A high-level tutorial about tracing deopts points](https://www.netguru.co/blog/tracing-patterns-hinder-performance) 483 | 484 | ### All bailout reasons 485 | 486 | * 32 bit value in register is not zero-extended 487 | * Alignment marker expected 488 | * Allocation is not double aligned 489 | * API call returned invalid object 490 | * Arguments object value in a test context 491 | * Array boilerplate creation failed 492 | * Array index constant value too big 493 | * Assignment to arguments 494 | * Assignment to let variable before initialization 495 | * Assignment to LOOKUP variable 496 | * ~~Assignment to parameter in arguments object~~ 497 | * Assignment to parameter, function uses arguments object 498 | * Bad value context for arguments object value 499 | * ~~Bad value context for arguments value~~ 500 | * Bailed out due to dependency change 501 | * Bailout was not prepared 502 | * Both registers were smis in SelectNonSmi 503 | * Call to a JavaScript runtime function 504 | * Class literal 505 | * Code generation failed 506 | * Code object not properly patched 507 | * Compound assignment to lookup slot 508 | * Computed property name 509 | * Context-allocated arguments 510 | * Copy buffers overlap 511 | * Could not generate +0.0 512 | * Could not generate -0.0 513 | * DebuggerStatement 514 | * Declaration in catch context 515 | * Declaration in with context 516 | * Default NaN mode not set 517 | * Delete with global variable 518 | * Delete with non-global variable 519 | * Destination of copy not aligned 520 | * Do expression encountered 521 | * DontDelete cells can't contain the hole 522 | * DoPushArgument not implemented for double type 523 | * Eliminated bounds check failed 524 | * EmitLoadRegister: Unsupported double immediate 525 | * eval 526 | * Expected +0.0 527 | * Expected alignment marker 528 | * Expected allocation site 529 | * Expected function object in register 530 | * Expected HeapNumber 531 | * Expected native context 532 | * Expected new space object 533 | * Expected non-identical objects 534 | * Expected non-null context 535 | * Expected undefined or cell in register 536 | * Expecting alignment for CopyBytes 537 | * Export declaration 538 | * External string expected, but not found 539 | * ForInStatement optimization is disabled 540 | * ~~ForInStatement with non-local each variable~~ 541 | * ForOfStatement 542 | * Frame is expected to be aligned 543 | * Function calls eval 544 | * Function is being debugged 545 | * Function with illegal redeclaration 546 | * Generated code is too large 547 | * Generator 548 | * Generator failed to resume 549 | * Global functions must have initial map 550 | * HeapNumberMap register clobbered 551 | * Import declaration 552 | * Index is negative 553 | * Index is too large 554 | * Inlined runtime function: FastOneByteArrayJoin 555 | * ~~Inlining bailed out~~ 556 | * Input GPR is expected to have upper32 cleared 557 | * Input string too long 558 | * Integer32ToSmiField writing to non-smi location 559 | * Invalid capture referenced 560 | * Invalid ElementsKind for InternalArray or InternalPackedArray 561 | * invalid full-codegen state 562 | * Invalid HandleScope level 563 | * Invalid left-hand side in assignment 564 | * Invalid lhs in compound assignment 565 | * Invalid lhs in count operation 566 | * Invalid min_length 567 | * JSGlobalObject::native_context should be a native context 568 | * JSGlobalProxy::context() should not be null 569 | * JSObject with fast elements map has slow elements 570 | * Let binding re-initialization 571 | * Live Bytes Count overflow chunk size 572 | * LiveEdit 573 | * Lookup variable in count operation 574 | * Map became deprecated 575 | * Map became unstable 576 | * Native function literal 577 | * Need a Smi literal here 578 | * No cases left 579 | * No empty arrays here in EmitFastOneByteArrayJoin 580 | * Non-initializer assignment to const 581 | * Non-object value 582 | * Non-smi index 583 | * Non-smi key in array literal 584 | * Non-smi value 585 | * Not enough spill slots for OSR 586 | * Not enough virtual registers (regalloc) 587 | * Not enough virtual registers for values 588 | * Object found in smi-only array 589 | * ~~Object literal with complex property~~ 590 | * Offset out of range 591 | * Operand is a smi 592 | * Operand is a smi and not a bound function 593 | * Operand is a smi and not a function 594 | * Operand is a smi and not a name 595 | * Operand is a smi and not a string 596 | * Operand is not a bound function 597 | * Operand is not a date 598 | * Operand is not a function 599 | * Operand is not a name 600 | * Operand is not a number 601 | * Operand is not a smi 602 | * Operand is not a string 603 | * Operand is not smi 604 | * Operand not a number 605 | * Optimization disabled by filter 606 | * Optimization is disabled 607 | * ~~Optimized too many times~~ 608 | * Out of virtual registers while trying to allocate temp register 609 | * Parse/scope error 610 | * Possible direct call to eval 611 | * Received invalid return address 612 | * ~~Reference to a variable which requires dynamic lookup~~ 613 | * Reference to global lexical variable 614 | * Reference to uninitialized variable 615 | * Register did not match expected root 616 | * Register was clobbered 617 | * Remembered set pointer is in new space 618 | * ~~Rest parameters~~ 619 | * Return address not found in frame 620 | * Should not directly enter OSR-compiled function 621 | * Sloppy function expects JSReceiver as receiver. 622 | * ~~Smi addition overflow~~ 623 | * ~~Smi subtraction overflow~~ 624 | * Spread in array literal 625 | * Stack access below stack pointer 626 | * Stack frame types must match 627 | * Super reference 628 | * The current stack pointer is below csp 629 | * The function_data field should be a BytecodeArray on interpreter entry 630 | * The object is not tagged 631 | * The object is tagged 632 | * The source and destination are the same 633 | * The stack pointer is not the expected value 634 | * The stack was corrupted by MacroAssembler::Call() 635 | * ~~Too many parameters~~ 636 | * Too many parameters/locals 637 | * Too many spill slots needed for OSR 638 | * ToOperand IsDoubleRegister unimplemented 639 | * ToOperand Unsupported double immediate 640 | * ToOperand32 unsupported immediate. 641 | * ~~TryCatchStatement~~ 642 | * ~~TryFinallyStatement~~ 643 | * Unaligned allocation in new space 644 | * Unaligned cell in write barrier 645 | * Unexpected allocation top 646 | * Unexpected color bit pattern found 647 | * Unexpected ElementsKind in array constructor 648 | * Unexpected fall-through from string comparison 649 | * Unexpected fallthrough from CharCodeAt slow case 650 | * Unexpected fallthrough from CharFromCode slow case 651 | * Unexpected fallthrough to CharCodeAt slow case 652 | * Unexpected fallthrough to CharFromCode slow case 653 | * Unexpected FPCR mode. 654 | * Unexpected FPU stack depth after instruction 655 | * Unexpected initial map for Array function 656 | * Unexpected initial map for Array function (1) 657 | * Unexpected initial map for Array function (2) 658 | * Unexpected initial map for InternalArray function 659 | * Unexpected level after return from api call 660 | * Unexpected negative value 661 | * Unexpected number of pre-allocated property fields 662 | * Unexpected smi value 663 | * Unexpected string type 664 | * Unexpected type for RegExp data, FixedArray expected 665 | * Unexpected value 666 | * Unexpectedly returned from a throw 667 | * ~~Unsupported const compound assignment~~ 668 | * Unsupported count operation with const 669 | * Unsupported double immediate 670 | * Unsupported let compound assignment 671 | * Unsupported lookup slot in declaration 672 | * Unsupported non-primitive compare 673 | * ~~Unsupported phi use of arguments~~ 674 | * ~~Unsupported phi use of const or let variable~~ 675 | * Unsupported switch statement 676 | * Unsupported tagged immediate 677 | * Variable resolved to with context 678 | * We should not have an empty lexical context 679 | * WithStatement 680 | * Wrong address or value passed to RecordWrite 681 | * Wrong context passed to function 682 | * ~~Yield~~ 683 | --------------------------------------------------------------------------------