<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[195831] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/195831">195831</a></dd>
<dt>Author</dt> <dd>sbarati@apple.com</dd>
<dt>Date</dt> <dd>2016-01-29 11:46:01 -0800 (Fri, 29 Jan 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Exits from exceptions shouldn't jettison code
https://bugs.webkit.org/show_bug.cgi?id=153564
Reviewed by Geoffrey Garen.
Source/JavaScriptCore:
We create two new exit kinds for exception-handling
OSRExits:
- ExceptionCheck: an exception check after a C call.
- GenericUnwind: an OSR exit executes because it's jumped to from genericUnwind machinery.
Having these two new exit kinds allows us to remove fields from
various OSRExit variants that store booleans indicating
if the exit is an exception handler, and if so, what kind
of exception handler. Most of this patch is just removing
those old fields and adding new equivalent functions.
This patch also implements the policy that we should never consider jettisoning
code from exits that happen from an exception check to an op_catch (it might be worth
considering a similar policy for 'throw'). We're choosing this policy because
it will almost never be more expensive, in total, to execute the OSR exit than
to execute the baseline variant of the code. When an exception is thrown, we do
really expensive work, like call through to genericUnwind, and also create an error
object with a stack trace. The cost of OSR exiting here is small in comparison to
those other operations. And penalizing a CodeBlock for OSR exiting from an exception
is silly because the basis of our implementation of exception handling in the
upper tiers is to OSR exit on a caught exception. So we used to penalize
ourselves for having an implementation that is correct w.r.t our design goals.
I've verified this hypothesis with on v8-raytrace by adding a new
benchmark that throws with very high frequency. Implementing
this policy on that benchmark results in about a 4-5% speed up.
* bytecode/ExitKind.cpp:
(JSC::exitKindToString):
(JSC::exitKindMayJettison):
(JSC::exitKindIsCountable): Deleted.
* bytecode/ExitKind.h:
* dfg/DFGJITCode.cpp:
(JSC::DFG::JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite):
* dfg/DFGJITCompiler.cpp:
(JSC::DFG::JITCompiler::noticeOSREntry):
(JSC::DFG::JITCompiler::appendExceptionHandlingOSRExit):
(JSC::DFG::JITCompiler::exceptionCheck):
(JSC::DFG::JITCompiler::recordCallSiteAndGenerateExceptionHandlingOSRExitIfNeeded):
* dfg/DFGJITCompiler.h:
* dfg/DFGOSRExit.cpp:
(JSC::DFG::OSRExit::OSRExit):
* dfg/DFGOSRExit.h:
(JSC::DFG::OSRExit::considerAddingAsFrequentExitSite):
* dfg/DFGOSRExitBase.h:
(JSC::DFG::OSRExitBase::OSRExitBase):
(JSC::DFG::OSRExitBase::isExceptionHandler):
(JSC::DFG::OSRExitBase::isGenericUnwindHandler):
(JSC::DFG::OSRExitBase::considerAddingAsFrequentExitSite):
* dfg/DFGOSRExitCompiler.cpp:
* dfg/DFGOSRExitCompiler32_64.cpp:
(JSC::DFG::OSRExitCompiler::compileExit):
* dfg/DFGOSRExitCompiler64.cpp:
(JSC::DFG::OSRExitCompiler::compileExit):
* dfg/DFGOSRExitCompilerCommon.cpp:
(JSC::DFG::handleExitCounts):
(JSC::DFG::osrWriteBarrier):
(JSC::DFG::adjustAndJumpToTarget):
* dfg/DFGOSRExitCompilerCommon.h:
(JSC::DFG::adjustFrameAndStackInOSRExitCompilerThunk):
* ftl/FTLCompile.cpp:
(JSC::FTL::mmAllocateDataSection):
* ftl/FTLExitThunkGenerator.cpp:
(JSC::FTL::ExitThunkGenerator::emitThunk):
* ftl/FTLJITCode.cpp:
(JSC::FTL::JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite):
* ftl/FTLLowerDFGToLLVM.cpp:
(JSC::FTL::DFG::LowerDFGToLLVM::callCheck):
(JSC::FTL::DFG::LowerDFGToLLVM::appendOSRExitArgumentsForPatchpointIfWillCatchException):
(JSC::FTL::DFG::LowerDFGToLLVM::appendOSRExit):
(JSC::FTL::DFG::LowerDFGToLLVM::blessSpeculation):
* ftl/FTLOSRExit.cpp:
(JSC::FTL::OSRExitDescriptor::emitOSRExit):
(JSC::FTL::OSRExitDescriptor::emitOSRExitLater):
(JSC::FTL::OSRExitDescriptor::prepareOSRExitHandle):
(JSC::FTL::OSRExit::OSRExit):
(JSC::FTL::OSRExit::spillRegistersToSpillSlot):
(JSC::FTL::OSRExit::recoverRegistersFromSpillSlot):
(JSC::FTL::OSRExit::willArriveAtExitFromIndirectExceptionCheck):
(JSC::FTL::OSRExit::willArriveAtOSRExitFromCallOperation):
(JSC::FTL::exceptionTypeWillArriveAtOSRExitFromGenericUnwind): Deleted.
(JSC::FTL::OSRExit::willArriveAtOSRExitFromGenericUnwind): Deleted.
* ftl/FTLOSRExit.h:
* ftl/FTLOSRExitCompiler.cpp:
(JSC::FTL::compileStub):
(JSC::FTL::compileFTLOSRExit):
* ftl/FTLPatchpointExceptionHandle.cpp:
(JSC::FTL::PatchpointExceptionHandle::scheduleExitCreation):
(JSC::FTL::PatchpointExceptionHandle::scheduleExitCreationForUnwind):
(JSC::FTL::PatchpointExceptionHandle::PatchpointExceptionHandle):
(JSC::FTL::PatchpointExceptionHandle::createHandle):
* ftl/FTLPatchpointExceptionHandle.h:
LayoutTests:
* js/regress/script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js: Added.
(randomException):
(Class.create):
(Object.extend):
(Flog.RayTracer.Color.prototype.initialize):
(Flog.RayTracer.Color.prototype.add):
(Flog.RayTracer.Color.prototype.addScalar):
(Flog.RayTracer.Color.prototype.subtract):
(Flog.RayTracer.Color.prototype.multiply):
(Flog.RayTracer.Color.prototype.multiplyScalar):
(Flog.RayTracer.Color.prototype.divideFactor):
(Flog.RayTracer.Color.prototype.limit):
(Flog.RayTracer.Color.prototype.distance):
(Flog.RayTracer.Color.prototype.blend):
(Flog.RayTracer.Color.prototype.brightness):
(Flog.RayTracer.Color.prototype.toString):
(Flog.RayTracer.Light.prototype.initialize):
(Flog.RayTracer.Light.prototype.toString):
(Flog.RayTracer.Vector.prototype.initialize):
(Flog.RayTracer.Vector.prototype.copy):
(Flog.RayTracer.Vector.prototype.normalize):
(Flog.RayTracer.Vector.prototype.magnitude):
(Flog.RayTracer.Vector.prototype.cross):
(Flog.RayTracer.Vector.prototype.dot):
(Flog.RayTracer.Vector.prototype.add):
(Flog.RayTracer.Vector.prototype.subtract):
(Flog.RayTracer.Vector.prototype.multiplyVector):
(Flog.RayTracer.Vector.prototype.multiplyScalar):
(Flog.RayTracer.Vector.prototype.toString):
(Flog.RayTracer.Ray.prototype.initialize):
(Flog.RayTracer.Ray.prototype.toString):
(Flog.RayTracer.Scene.prototype.initialize):
(Flog.RayTracer.Material.BaseMaterial.prototype.initialize):
(Flog.RayTracer.Material.BaseMaterial.prototype.getColor):
(Flog.RayTracer.Material.BaseMaterial.prototype.wrapUp):
(Flog.RayTracer.Material.BaseMaterial.prototype.toString):
(Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.initialize):
(Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.getColor):
(Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.toString):
(Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial):
(Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.initialize):
(Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.getColor):
(Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.toString):
(Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial):
(Flog.RayTracer.Shape.Sphere.prototype.initialize):
(Flog.RayTracer.Shape.Sphere.prototype.intersect):
(Flog.RayTracer.Shape.Sphere.prototype.toString):
(Flog.RayTracer.Shape.Plane.prototype.initialize):
(Flog.RayTracer.Shape.Plane.prototype.intersect):
(Flog.RayTracer.Shape.Plane.prototype.toString):
(Flog.RayTracer.IntersectionInfo.prototype.initialize):
(Flog.RayTracer.IntersectionInfo.prototype.toString):
(Flog.RayTracer.Camera.prototype.initialize):
(Flog.RayTracer.Camera.prototype.getRay):
(Flog.RayTracer.Camera.prototype.toString):
(Flog.RayTracer.Background.prototype.initialize):
(Flog.RayTracer.Engine.prototype.initialize):
(Flog.RayTracer.Engine.prototype.setPixel):
(Flog.RayTracer.Engine.prototype.renderScene):
(Flog.RayTracer.Engine.prototype.getPixelColor):
(Flog.RayTracer.Engine.prototype.testIntersection):
(Flog.RayTracer.Engine.prototype.getReflectionRay):
(Flog.RayTracer.Engine.prototype.rayTrace):
(renderScene):
* js/regress/v8-raytrace-with-try-catch-high-frequency-throws-expected.txt: Added.
* js/regress/v8-raytrace-with-try-catch-high-frequency-throws.html: Added.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCorebytecodeExitKindcpp">trunk/Source/JavaScriptCore/bytecode/ExitKind.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorebytecodeExitKindh">trunk/Source/JavaScriptCore/bytecode/ExitKind.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCodecpp">trunk/Source/JavaScriptCore/dfg/DFGJITCode.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCompilercpp">trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCompilerh">trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitcpp">trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExith">trunk/Source/JavaScriptCore/dfg/DFGOSRExit.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitBaseh">trunk/Source/JavaScriptCore/dfg/DFGOSRExitBase.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitCompilercpp">trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitCompiler32_64cpp">trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitCompiler64cpp">trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitCompilerCommoncpp">trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSRExitCompilerCommonh">trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLCompilecpp">trunk/Source/JavaScriptCore/ftl/FTLCompile.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLExitThunkGeneratorcpp">trunk/Source/JavaScriptCore/ftl/FTLExitThunkGenerator.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLJITCodecpp">trunk/Source/JavaScriptCore/ftl/FTLJITCode.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLLowerDFGToLLVMcpp">trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLOSRExitcpp">trunk/Source/JavaScriptCore/ftl/FTLOSRExit.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLOSRExith">trunk/Source/JavaScriptCore/ftl/FTLOSRExit.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLOSRExitCompilercpp">trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLPatchpointExceptionHandlecpp">trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLPatchpointExceptionHandleh">trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.h</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsjsregressscripttestsv8raytracewithtrycatchhighfrequencythrowsjs">trunk/LayoutTests/js/regress/script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js</a></li>
<li><a href="#trunkLayoutTestsjsregressv8raytracewithtrycatchhighfrequencythrowsexpectedtxt">trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws-expected.txt</a></li>
<li><a href="#trunkLayoutTestsjsregressv8raytracewithtrycatchhighfrequencythrowshtml">trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws.html</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/LayoutTests/ChangeLog 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -1,3 +1,77 @@
</span><ins>+2016-01-29 Saam barati <sbarati@apple.com>
+
+ Exits from exceptions shouldn't jettison code
+ https://bugs.webkit.org/show_bug.cgi?id=153564
+
+ Reviewed by Geoffrey Garen.
+
+ * js/regress/script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js: Added.
+ (randomException):
+ (Class.create):
+ (Object.extend):
+ (Flog.RayTracer.Color.prototype.initialize):
+ (Flog.RayTracer.Color.prototype.add):
+ (Flog.RayTracer.Color.prototype.addScalar):
+ (Flog.RayTracer.Color.prototype.subtract):
+ (Flog.RayTracer.Color.prototype.multiply):
+ (Flog.RayTracer.Color.prototype.multiplyScalar):
+ (Flog.RayTracer.Color.prototype.divideFactor):
+ (Flog.RayTracer.Color.prototype.limit):
+ (Flog.RayTracer.Color.prototype.distance):
+ (Flog.RayTracer.Color.prototype.blend):
+ (Flog.RayTracer.Color.prototype.brightness):
+ (Flog.RayTracer.Color.prototype.toString):
+ (Flog.RayTracer.Light.prototype.initialize):
+ (Flog.RayTracer.Light.prototype.toString):
+ (Flog.RayTracer.Vector.prototype.initialize):
+ (Flog.RayTracer.Vector.prototype.copy):
+ (Flog.RayTracer.Vector.prototype.normalize):
+ (Flog.RayTracer.Vector.prototype.magnitude):
+ (Flog.RayTracer.Vector.prototype.cross):
+ (Flog.RayTracer.Vector.prototype.dot):
+ (Flog.RayTracer.Vector.prototype.add):
+ (Flog.RayTracer.Vector.prototype.subtract):
+ (Flog.RayTracer.Vector.prototype.multiplyVector):
+ (Flog.RayTracer.Vector.prototype.multiplyScalar):
+ (Flog.RayTracer.Vector.prototype.toString):
+ (Flog.RayTracer.Ray.prototype.initialize):
+ (Flog.RayTracer.Ray.prototype.toString):
+ (Flog.RayTracer.Scene.prototype.initialize):
+ (Flog.RayTracer.Material.BaseMaterial.prototype.initialize):
+ (Flog.RayTracer.Material.BaseMaterial.prototype.getColor):
+ (Flog.RayTracer.Material.BaseMaterial.prototype.wrapUp):
+ (Flog.RayTracer.Material.BaseMaterial.prototype.toString):
+ (Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.initialize):
+ (Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.getColor):
+ (Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.toString):
+ (Flog.RayTracer.Material.Solid.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial):
+ (Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.initialize):
+ (Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.getColor):
+ (Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial.toString):
+ (Flog.RayTracer.Material.Chessboard.prototype.Object.extend.new.Flog.RayTracer.Material.BaseMaterial):
+ (Flog.RayTracer.Shape.Sphere.prototype.initialize):
+ (Flog.RayTracer.Shape.Sphere.prototype.intersect):
+ (Flog.RayTracer.Shape.Sphere.prototype.toString):
+ (Flog.RayTracer.Shape.Plane.prototype.initialize):
+ (Flog.RayTracer.Shape.Plane.prototype.intersect):
+ (Flog.RayTracer.Shape.Plane.prototype.toString):
+ (Flog.RayTracer.IntersectionInfo.prototype.initialize):
+ (Flog.RayTracer.IntersectionInfo.prototype.toString):
+ (Flog.RayTracer.Camera.prototype.initialize):
+ (Flog.RayTracer.Camera.prototype.getRay):
+ (Flog.RayTracer.Camera.prototype.toString):
+ (Flog.RayTracer.Background.prototype.initialize):
+ (Flog.RayTracer.Engine.prototype.initialize):
+ (Flog.RayTracer.Engine.prototype.setPixel):
+ (Flog.RayTracer.Engine.prototype.renderScene):
+ (Flog.RayTracer.Engine.prototype.getPixelColor):
+ (Flog.RayTracer.Engine.prototype.testIntersection):
+ (Flog.RayTracer.Engine.prototype.getReflectionRay):
+ (Flog.RayTracer.Engine.prototype.rayTrace):
+ (renderScene):
+ * js/regress/v8-raytrace-with-try-catch-high-frequency-throws-expected.txt: Added.
+ * js/regress/v8-raytrace-with-try-catch-high-frequency-throws.html: Added.
+
</ins><span class="cx"> 2016-01-29 Carlos Alberto Lopez Perez <clopez@igalia.com>
</span><span class="cx">
</span><span class="cx"> [GTK] Unreviewed gardening after r195740 (v2).
</span></span></pre></div>
<a id="trunkLayoutTestsjsregressscripttestsv8raytracewithtrycatchhighfrequencythrowsjs"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/js/regress/script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js (0 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/js/regress/script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js (rev 0)
+++ trunk/LayoutTests/js/regress/script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -0,0 +1,1101 @@
</span><ins>+// The ray tracer code in this file is written by Adam Burmister. It
+// is available in its original form from:
+//
+// http://labs.flog.nz.co/raytracer/
+//
+// It has been modified slightly by Google to work as a standalone
+// benchmark, but the all the computational code remains
+// untouched. This file also contains a copy of parts of the Prototype
+// JavaScript framework which is used by the ray tracer.
+
+// Variable used to hold a number that can be used to verify that
+// the scene was ray traced correctly.
+var checkNumber;
+
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+
+// The following is a copy of parts of the Prototype JavaScript library:
+
+// Prototype JavaScript framework, version 1.5.0
+// (c) 2005-2007 Sam Stephenson
+//
+// Prototype is freely distributable under the terms of an MIT-style license.
+// For details, see the Prototype web site: http://prototype.conio.net/
+
+let __exceptionCounter = 0;
+function randomException() {
+ __exceptionCounter++;
+ if (__exceptionCounter % 35 === 0) {
+ throw new Error("rando");
+ }
+}
+noInline(randomException);
+
+var Class = {
+ create: function() {
+ return function() {
+ try {
+ this.initialize.apply(this, arguments);
+ randomException();
+ } catch(e) { }
+ }
+ }
+};
+
+
+Object.extend = function(destination, source) {
+ for (var property in source) {
+ try {
+ destination[property] = source[property];
+ randomException();
+ } catch(e) { }
+ }
+ return destination;
+};
+
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+
+// The rest of this file is the actual ray tracer written by Adam
+// Burmister. It's a concatenation of the following files:
+//
+// flog/color.js
+// flog/light.js
+// flog/vector.js
+// flog/ray.js
+// flog/scene.js
+// flog/material/basematerial.js
+// flog/material/solid.js
+// flog/material/chessboard.js
+// flog/shape/baseshape.js
+// flog/shape/sphere.js
+// flog/shape/plane.js
+// flog/intersectioninfo.js
+// flog/camera.js
+// flog/background.js
+// flog/engine.js
+
+
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Color = Class.create();
+
+Flog.RayTracer.Color.prototype = {
+ red : 0.0,
+ green : 0.0,
+ blue : 0.0,
+
+ initialize : function(r, g, b) {
+ try {
+ if(!r) r = 0.0;
+ if(!g) g = 0.0;
+ if(!b) b = 0.0;
+
+ this.red = r;
+ this.green = g;
+ this.blue = b;
+ randomException();
+ } catch(e) { }
+ },
+
+ add : function(c1, c2){
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+
+ result.red = c1.red + c2.red;
+ result.green = c1.green + c2.green;
+ result.blue = c1.blue + c2.blue;
+
+ randomException();
+ } catch(e) { }
+
+ return result;
+ },
+
+ addScalar: function(c1, s){
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+
+ result.red = c1.red + s;
+ result.green = c1.green + s;
+ result.blue = c1.blue + s;
+
+ result.limit();
+
+ randomException();
+ } catch(e) { }
+
+ return result;
+ },
+
+ subtract: function(c1, c2){
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+
+ result.red = c1.red - c2.red;
+ result.green = c1.green - c2.green;
+ result.blue = c1.blue - c2.blue;
+
+ randomException();
+ } catch(e) { }
+
+ return result;
+ },
+
+ multiply : function(c1, c2) {
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+
+ result.red = c1.red * c2.red;
+ result.green = c1.green * c2.green;
+ result.blue = c1.blue * c2.blue;
+
+ randomException();
+ } catch(e) { }
+
+ return result;
+ },
+
+ multiplyScalar : function(c1, f) {
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+
+ result.red = c1.red * f;
+ result.green = c1.green * f;
+ result.blue = c1.blue * f;
+
+ randomException();
+ } catch(e) { }
+
+ return result;
+ },
+
+ divideFactor : function(c1, f) {
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+
+ result.red = c1.red / f;
+ result.green = c1.green / f;
+ result.blue = c1.blue / f;
+
+ randomException();
+ } catch(e) { }
+
+ return result;
+ },
+
+ limit: function(){
+ try {
+ this.red = (this.red > 0.0) ? ( (this.red > 1.0) ? 1.0 : this.red ) : 0.0;
+ this.green = (this.green > 0.0) ? ( (this.green > 1.0) ? 1.0 : this.green ) : 0.0;
+ this.blue = (this.blue > 0.0) ? ( (this.blue > 1.0) ? 1.0 : this.blue ) : 0.0;
+
+ randomException();
+ } catch(e) { }
+ },
+
+ distance : function(color) {
+ try {
+ var d = Math.abs(this.red - color.red) + Math.abs(this.green - color.green) + Math.abs(this.blue - color.blue);
+ randomException();
+ } catch(e) { }
+ return d;
+ },
+
+ blend: function(c1, c2, w){
+ try {
+ var result = new Flog.RayTracer.Color(0,0,0);
+ result = Flog.RayTracer.Color.prototype.add(
+ Flog.RayTracer.Color.prototype.multiplyScalar(c1, 1 - w),
+ Flog.RayTracer.Color.prototype.multiplyScalar(c2, w)
+ );
+ randomException();
+ } catch(e) { }
+ return result;
+ },
+
+ brightness : function() {
+ try {
+ var r = Math.floor(this.red*255);
+ var g = Math.floor(this.green*255);
+ var b = Math.floor(this.blue*255);
+ randomException();
+ } catch(e) { }
+ return (r * 77 + g * 150 + b * 29) >> 8;
+ },
+
+ toString : function () {
+ try {
+ var r = Math.floor(this.red*255);
+ var g = Math.floor(this.green*255);
+ var b = Math.floor(this.blue*255);
+ randomException();
+ } catch(e) { }
+
+ return "rgb("+ r +","+ g +","+ b +")";
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Light = Class.create();
+
+Flog.RayTracer.Light.prototype = {
+ position: null,
+ color: null,
+ intensity: 10.0,
+
+ initialize : function(pos, color, intensity) {
+ try {
+ this.position = pos;
+ this.color = color;
+ this.intensity = (intensity ? intensity : 10.0);
+
+ randomException();
+ } catch(e) { }
+ },
+
+ toString : function () {
+ try {
+ var result = 'Light [' + this.position.x + ',' + this.position.y + ',' + this.position.z + ']';
+ randomException();
+ } catch(e) { }
+ return result;
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Vector = Class.create();
+
+Flog.RayTracer.Vector.prototype = {
+ x : 0.0,
+ y : 0.0,
+ z : 0.0,
+
+ initialize : function(x, y, z) {
+ try {
+ this.x = (x ? x : 0);
+ this.y = (y ? y : 0);
+ this.z = (z ? z : 0);
+ randomException();
+ } catch(e) { }
+ },
+
+ copy: function(vector){
+ try {
+ this.x = vector.x;
+ this.y = vector.y;
+ this.z = vector.z;
+ randomException();
+ } catch(e) { }
+ },
+
+ normalize : function() {
+ try {
+ var m = this.magnitude();
+ var result = new Flog.RayTracer.Vector(this.x / m, this.y / m, this.z / m);
+ randomException();
+ } catch(e) { }
+ return result;
+ },
+
+ magnitude : function() {
+ try {
+ return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z * this.z));
+ } catch(e) { }
+ },
+
+ cross : function(w) {
+ try {
+ return new Flog.RayTracer.Vector(
+ -this.z * w.y + this.y * w.z,
+ this.z * w.x - this.x * w.z,
+ -this.y * w.x + this.x * w.y);
+ } catch(e) { }
+ },
+
+ dot : function(w) {
+ try {
+ return this.x * w.x + this.y * w.y + this.z * w.z;
+ } catch(e) { }
+ },
+
+ add : function(v, w) {
+ try {
+ return new Flog.RayTracer.Vector(w.x + v.x, w.y + v.y, w.z + v.z);
+ } catch(e) { }
+ },
+
+ subtract : function(v, w) {
+ try {
+ if(!w || !v) throw 'Vectors must be defined [' + v + ',' + w + ']';
+ return new Flog.RayTracer.Vector(v.x - w.x, v.y - w.y, v.z - w.z);
+ } catch(e) { }
+ },
+
+ multiplyVector : function(v, w) {
+ try {
+ return new Flog.RayTracer.Vector(v.x * w.x, v.y * w.y, v.z * w.z);
+ } catch(e) { }
+ },
+
+ multiplyScalar : function(v, w) {
+ try {
+ return new Flog.RayTracer.Vector(v.x * w, v.y * w, v.z * w);
+ } catch(e) { }
+ },
+
+ toString : function () {
+ try {
+ return 'Vector [' + this.x + ',' + this.y + ',' + this.z + ']';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Ray = Class.create();
+
+Flog.RayTracer.Ray.prototype = {
+ position : null,
+ direction : null,
+ initialize : function(pos, dir) {
+ try {
+ this.position = pos;
+ this.direction = dir;
+ randomException();
+ } catch(e) { }
+ },
+
+ toString : function () {
+ try {
+ return 'Ray [' + this.position + ',' + this.direction + ']';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Scene = Class.create();
+
+Flog.RayTracer.Scene.prototype = {
+ camera : null,
+ shapes : [],
+ lights : [],
+ background : null,
+
+ initialize : function() {
+ try {
+ this.camera = new Flog.RayTracer.Camera(
+ new Flog.RayTracer.Vector(0,0,-5),
+ new Flog.RayTracer.Vector(0,0,1),
+ new Flog.RayTracer.Vector(0,1,0)
+ );
+ this.shapes = new Array();
+ this.lights = new Array();
+ this.background = new Flog.RayTracer.Background(new Flog.RayTracer.Color(0,0,0.5), 0.2);
+
+ randomException();
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+if(typeof(Flog.RayTracer.Material) == 'undefined') Flog.RayTracer.Material = {};
+
+Flog.RayTracer.Material.BaseMaterial = Class.create();
+
+Flog.RayTracer.Material.BaseMaterial.prototype = {
+
+ gloss: 2.0, // [0...infinity] 0 = matt
+ transparency: 0.0, // 0=opaque
+ reflection: 0.0, // [0...infinity] 0 = no reflection
+ refraction: 0.50,
+ hasTexture: false,
+
+ initialize : function() {
+
+ },
+
+ getColor: function(u, v){
+
+ },
+
+ wrapUp: function(t){
+ try {
+ t = t % 2.0;
+ if(t < -1) t += 2.0;
+ if(t >= 1) t -= 2.0;
+ randomException();
+ } catch(e) { }
+ return t;
+ },
+
+ toString : function () {
+ try {
+ return 'Material [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Material.Solid = Class.create();
+
+Flog.RayTracer.Material.Solid.prototype = Object.extend(
+ new Flog.RayTracer.Material.BaseMaterial(), {
+ initialize : function(color, reflection, refraction, transparency, gloss) {
+ try {
+ this.color = color;
+ this.reflection = reflection;
+ this.transparency = transparency;
+ this.gloss = gloss;
+ this.hasTexture = false;
+ randomException();
+ } catch(e) { }
+ },
+
+ getColor: function(u, v){
+ try {
+ return this.color;
+ } catch(e) { }
+ },
+
+ toString : function () {
+ try {
+ return 'SolidMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
+ } catch(e) { }
+ }
+ }
+ );
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Material.Chessboard = Class.create();
+
+Flog.RayTracer.Material.Chessboard.prototype = Object.extend(
+ new Flog.RayTracer.Material.BaseMaterial(), {
+ colorEven: null,
+ colorOdd: null,
+ density: 0.5,
+
+ initialize : function(colorEven, colorOdd, reflection, transparency, gloss, density) {
+ try {
+ this.colorEven = colorEven;
+ this.colorOdd = colorOdd;
+ this.reflection = reflection;
+ this.transparency = transparency;
+ this.gloss = gloss;
+ this.density = density;
+ this.hasTexture = true;
+ randomException();
+ } catch(e) { }
+ },
+
+ getColor: function(u, v){
+ try {
+ var t = this.wrapUp(u * this.density) * this.wrapUp(v * this.density);
+ randomException();
+ } catch(e) { }
+
+ if(t < 0.0)
+ return this.colorEven;
+ else
+ return this.colorOdd;
+ },
+
+ toString : function () {
+ try {
+ return 'ChessMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
+ } catch(e) { }
+ }
+ }
+);
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};
+
+Flog.RayTracer.Shape.Sphere = Class.create();
+
+Flog.RayTracer.Shape.Sphere.prototype = {
+ initialize : function(pos, radius, material) {
+ try {
+ this.radius = radius;
+ this.position = pos;
+ this.material = material;
+
+ randomException();
+ } catch(e) { }
+ },
+
+ intersect: function(ray){
+ try {
+ var info = new Flog.RayTracer.IntersectionInfo();
+ info.shape = this;
+
+ var dst = Flog.RayTracer.Vector.prototype.subtract(ray.position, this.position);
+
+ var B = dst.dot(ray.direction);
+ var C = dst.dot(dst) - (this.radius * this.radius);
+ var D = (B * B) - C;
+
+ if(D > 0){ // intersection!
+ info.isHit = true;
+ info.distance = (-B) - Math.sqrt(D);
+ info.position = Flog.RayTracer.Vector.prototype.add(
+ ray.position,
+ Flog.RayTracer.Vector.prototype.multiplyScalar(
+ ray.direction,
+ info.distance
+ )
+ );
+ info.normal = Flog.RayTracer.Vector.prototype.subtract(
+ info.position,
+ this.position
+ ).normalize();
+
+ info.color = this.material.getColor(0,0);
+ } else {
+ info.isHit = false;
+ }
+
+ randomException();
+ } catch(e) { }
+ return info;
+ },
+
+ toString : function () {
+ try {
+ return 'Sphere [position=' + this.position + ', radius=' + this.radius + ']';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};
+
+Flog.RayTracer.Shape.Plane = Class.create();
+
+Flog.RayTracer.Shape.Plane.prototype = {
+ d: 0.0,
+
+ initialize : function(pos, d, material) {
+ try {
+ this.position = pos;
+ this.d = d;
+ this.material = material;
+ randomException();
+ } catch(e) { }
+ },
+
+ intersect: function(ray){
+ try {
+ var info = new Flog.RayTracer.IntersectionInfo();
+
+ var Vd = this.position.dot(ray.direction);
+ if(Vd == 0) return info; // no intersection
+
+ var t = -(this.position.dot(ray.position) + this.d) / Vd;
+ if(t <= 0) return info;
+
+ info.shape = this;
+ info.isHit = true;
+ info.position = Flog.RayTracer.Vector.prototype.add(
+ ray.position,
+ Flog.RayTracer.Vector.prototype.multiplyScalar(
+ ray.direction,
+ t
+ )
+ );
+ info.normal = this.position;
+ info.distance = t;
+
+ if(this.material.hasTexture){
+ var vU = new Flog.RayTracer.Vector(this.position.y, this.position.z, -this.position.x);
+ var vV = vU.cross(this.position);
+ var u = info.position.dot(vU);
+ var v = info.position.dot(vV);
+ info.color = this.material.getColor(u,v);
+ } else {
+ info.color = this.material.getColor(0,0);
+ }
+
+ randomException();
+ } catch(e) { }
+ return info;
+ },
+
+ toString : function () {
+ try {
+ return 'Plane [' + this.position + ', d=' + this.d + ']';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.IntersectionInfo = Class.create();
+
+Flog.RayTracer.IntersectionInfo.prototype = {
+ isHit: false,
+ hitCount: 0,
+ shape: null,
+ position: null,
+ normal: null,
+ color: null,
+ distance: null,
+
+ initialize : function() {
+ try {
+ this.color = new Flog.RayTracer.Color(0,0,0);
+ randomException();
+ } catch(e) { }
+ },
+
+ toString : function () {
+ try {
+ return 'Intersection [' + this.position + ']';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Camera = Class.create();
+
+Flog.RayTracer.Camera.prototype = {
+ position: null,
+ lookAt: null,
+ equator: null,
+ up: null,
+ screen: null,
+
+ initialize : function(pos, lookAt, up) {
+ try {
+ this.position = pos;
+ this.lookAt = lookAt;
+ this.up = up;
+ this.equator = lookAt.normalize().cross(this.up);
+ this.screen = Flog.RayTracer.Vector.prototype.add(this.position, this.lookAt);
+ randomException();
+ } catch(e) { }
+ },
+
+ getRay: function(vx, vy){
+ try {
+ var pos = Flog.RayTracer.Vector.prototype.subtract(
+ this.screen,
+ Flog.RayTracer.Vector.prototype.subtract(
+ Flog.RayTracer.Vector.prototype.multiplyScalar(this.equator, vx),
+ Flog.RayTracer.Vector.prototype.multiplyScalar(this.up, vy)
+ )
+ );
+ pos.y = pos.y * -1;
+ var dir = Flog.RayTracer.Vector.prototype.subtract(
+ pos,
+ this.position
+ );
+
+ var ray = new Flog.RayTracer.Ray(pos, dir.normalize());
+
+ randomException();
+ } catch(e) { }
+ return ray;
+ },
+
+ toString : function () {
+ try {
+ return 'Ray []';
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Background = Class.create();
+
+Flog.RayTracer.Background.prototype = {
+ color : null,
+ ambience : 0.0,
+
+ initialize : function(color, ambience) {
+ try {
+ this.color = color;
+ this.ambience = ambience;
+ randomException();
+ } catch(e) { }
+ }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Engine = Class.create();
+
+Flog.RayTracer.Engine.prototype = {
+ canvas: null, /* 2d context we can render to */
+
+ initialize: function(options){
+ try {
+ this.options = Object.extend({
+ canvasHeight: 100,
+ canvasWidth: 100,
+ pixelWidth: 2,
+ pixelHeight: 2,
+ renderDiffuse: false,
+ renderShadows: false,
+ renderHighlights: false,
+ renderReflections: false,
+ rayDepth: 2
+ }, options || {});
+
+ this.options.canvasHeight /= this.options.pixelHeight;
+ this.options.canvasWidth /= this.options.pixelWidth;
+
+ randomException();
+ } catch(e) { }
+
+ /* TODO: dynamically include other scripts */
+ },
+
+ setPixel: function(x, y, color){
+ try {
+ var pxW, pxH;
+ pxW = this.options.pixelWidth;
+ pxH = this.options.pixelHeight;
+
+ if (this.canvas) {
+ this.canvas.fillStyle = color.toString();
+ this.canvas.fillRect (x * pxW, y * pxH, pxW, pxH);
+ } else {
+ if (x === y) {
+ checkNumber += color.brightness();
+ }
+ // print(x * pxW, y * pxH, pxW, pxH);
+ }
+
+ randomException();
+ } catch(e) { }
+ },
+
+ renderScene: function(scene, canvas){
+ try {
+ checkNumber = 0;
+ /* Get canvas */
+ if (canvas) {
+ this.canvas = canvas.getContext("2d");
+ } else {
+ this.canvas = null;
+ }
+
+ var canvasHeight = this.options.canvasHeight;
+ var canvasWidth = this.options.canvasWidth;
+
+ for(var y=0; y < canvasHeight; y++){
+ for(var x=0; x < canvasWidth; x++){
+ try {
+ var yp = y * 1.0 / canvasHeight * 2 - 1;
+ var xp = x * 1.0 / canvasWidth * 2 - 1;
+
+ var ray = scene.camera.getRay(xp, yp);
+
+ var color = this.getPixelColor(ray, scene);
+
+ this.setPixel(x, y, color);
+
+ randomException();
+ } catch(e) { }
+ }
+ }
+ } catch(e) { }
+ if (checkNumber !== 2321) {
+ throw new Error("Scene rendered incorrectly");
+ }
+ },
+
+ getPixelColor: function(ray, scene){
+ try {
+ var info = this.testIntersection(ray, scene, null);
+ if(info.isHit){
+ var color = this.rayTrace(info, ray, scene, 0);
+ return color;
+ }
+ return scene.background.color;
+ } catch(e) { }
+ },
+
+ testIntersection: function(ray, scene, exclude){
+ try {
+ var hits = 0;
+ var best = new Flog.RayTracer.IntersectionInfo();
+ best.distance = 2000;
+
+ for(var i=0; i<scene.shapes.length; i++){
+ try {
+ var shape = scene.shapes[i];
+
+ if(shape != exclude){
+ var info = shape.intersect(ray);
+ if(info.isHit && info.distance >= 0 && info.distance < best.distance){
+ best = info;
+ hits++;
+ }
+ }
+
+ randomException();
+ } catch(e) { }
+ }
+ best.hitCount = hits;
+
+ randomException();
+ } catch(e) { }
+ return best;
+ },
+
+ getReflectionRay: function(P,N,V){
+ try {
+ var c1 = -N.dot(V);
+ var R1 = Flog.RayTracer.Vector.prototype.add(
+ Flog.RayTracer.Vector.prototype.multiplyScalar(N, 2*c1),
+ V
+ );
+
+ randomException();
+ } catch(e) { }
+ return new Flog.RayTracer.Ray(P, R1);
+ },
+
+ rayTrace: function(info, ray, scene, depth){
+ // Calc ambient
+ try {
+ var color = Flog.RayTracer.Color.prototype.multiplyScalar(info.color, scene.background.ambience);
+ var oldColor = color;
+ var shininess = Math.pow(10, info.shape.material.gloss + 1);
+
+ for(var i=0; i<scene.lights.length; i++){
+ try {
+ var light = scene.lights[i];
+
+ // Calc diffuse lighting
+ var v = Flog.RayTracer.Vector.prototype.subtract(
+ light.position,
+ info.position
+ ).normalize();
+
+ if(this.options.renderDiffuse){
+ var L = v.dot(info.normal);
+ if(L > 0.0){
+ color = Flog.RayTracer.Color.prototype.add(
+ color,
+ Flog.RayTracer.Color.prototype.multiply(
+ info.color,
+ Flog.RayTracer.Color.prototype.multiplyScalar(
+ light.color,
+ L
+ )
+ )
+ );
+ }
+ }
+
+ randomException();
+ } catch(e) { }
+
+ try {
+ // The greater the depth the more accurate the colours, but
+ // this is exponentially (!) expensive
+ if(depth <= this.options.rayDepth){
+ // calculate reflection ray
+ if(this.options.renderReflections && info.shape.material.reflection > 0)
+ {
+ var reflectionRay = this.getReflectionRay(info.position, info.normal, ray.direction);
+ var refl = this.testIntersection(reflectionRay, scene, info.shape);
+
+ if (refl.isHit && refl.distance > 0){
+ refl.color = this.rayTrace(refl, reflectionRay, scene, depth + 1);
+ } else {
+ refl.color = scene.background.color;
+ }
+
+ color = Flog.RayTracer.Color.prototype.blend(
+ color,
+ refl.color,
+ info.shape.material.reflection
+ );
+ }
+
+ // Refraction
+ /* TODO */
+ }
+ randomException();
+ } catch(e) { }
+
+ /* Render shadows and highlights */
+
+ var shadowInfo = new Flog.RayTracer.IntersectionInfo();
+
+ if(this.options.renderShadows){
+ var shadowRay = new Flog.RayTracer.Ray(info.position, v);
+
+ shadowInfo = this.testIntersection(shadowRay, scene, info.shape);
+ if(shadowInfo.isHit && shadowInfo.shape != info.shape /*&& shadowInfo.shape.type != 'PLANE'*/){
+ var vA = Flog.RayTracer.Color.prototype.multiplyScalar(color, 0.5);
+ var dB = (0.5 * Math.pow(shadowInfo.shape.material.transparency, 0.5));
+ color = Flog.RayTracer.Color.prototype.addScalar(vA,dB);
+ }
+ }
+
+ try {
+ // Phong specular highlights
+ if(this.options.renderHighlights && !shadowInfo.isHit && info.shape.material.gloss > 0){
+ var Lv = Flog.RayTracer.Vector.prototype.subtract(
+ info.shape.position,
+ light.position
+ ).normalize();
+
+ var E = Flog.RayTracer.Vector.prototype.subtract(
+ scene.camera.position,
+ info.shape.position
+ ).normalize();
+
+ var H = Flog.RayTracer.Vector.prototype.subtract(
+ E,
+ Lv
+ ).normalize();
+
+ var glossWeight = Math.pow(Math.max(info.normal.dot(H), 0), shininess);
+ color = Flog.RayTracer.Color.prototype.add(
+ Flog.RayTracer.Color.prototype.multiplyScalar(light.color, glossWeight),
+ color
+ );
+ }
+ randomException();
+ } catch(e) { }
+ }
+ color.limit();
+
+ randomException();
+ } catch(e) { }
+ return color;
+ }
+};
+
+
+function renderScene(){
+ try {
+ var scene = new Flog.RayTracer.Scene();
+
+ scene.camera = new Flog.RayTracer.Camera(
+ new Flog.RayTracer.Vector(0, 0, -15),
+ new Flog.RayTracer.Vector(-0.2, 0, 5),
+ new Flog.RayTracer.Vector(0, 1, 0)
+ );
+
+ scene.background = new Flog.RayTracer.Background(
+ new Flog.RayTracer.Color(0.5, 0.5, 0.5),
+ 0.4
+ );
+
+ var sphere = new Flog.RayTracer.Shape.Sphere(
+ new Flog.RayTracer.Vector(-1.5, 1.5, 2),
+ 1.5,
+ new Flog.RayTracer.Material.Solid(
+ new Flog.RayTracer.Color(0,0.5,0.5),
+ 0.3,
+ 0.0,
+ 0.0,
+ 2.0
+ )
+ );
+
+ var sphere1 = new Flog.RayTracer.Shape.Sphere(
+ new Flog.RayTracer.Vector(1, 0.25, 1),
+ 0.5,
+ new Flog.RayTracer.Material.Solid(
+ new Flog.RayTracer.Color(0.9,0.9,0.9),
+ 0.1,
+ 0.0,
+ 0.0,
+ 1.5
+ )
+ );
+
+ var plane = new Flog.RayTracer.Shape.Plane(
+ new Flog.RayTracer.Vector(0.1, 0.9, -0.5).normalize(),
+ 1.2,
+ new Flog.RayTracer.Material.Chessboard(
+ new Flog.RayTracer.Color(1,1,1),
+ new Flog.RayTracer.Color(0,0,0),
+ 0.2,
+ 0.0,
+ 1.0,
+ 0.7
+ )
+ );
+
+ scene.shapes.push(plane);
+ scene.shapes.push(sphere);
+ scene.shapes.push(sphere1);
+
+ var light = new Flog.RayTracer.Light(
+ new Flog.RayTracer.Vector(5, 10, -1),
+ new Flog.RayTracer.Color(0.8, 0.8, 0.8)
+ );
+
+ var light1 = new Flog.RayTracer.Light(
+ new Flog.RayTracer.Vector(-3, 5, -15),
+ new Flog.RayTracer.Color(0.8, 0.8, 0.8),
+ 100
+ );
+
+ scene.lights.push(light);
+ scene.lights.push(light1);
+
+ var imageWidth = 100; // $F('imageWidth');
+ var imageHeight = 100; // $F('imageHeight');
+ var pixelSize = "5,5".split(','); // $F('pixelSize').split(',');
+ var renderDiffuse = true; // $F('renderDiffuse');
+ var renderShadows = true; // $F('renderShadows');
+ var renderHighlights = true; // $F('renderHighlights');
+ var renderReflections = true; // $F('renderReflections');
+ var rayDepth = 2;//$F('rayDepth');
+
+ var raytracer = new Flog.RayTracer.Engine(
+ {
+ canvasWidth: imageWidth,
+ canvasHeight: imageHeight,
+ pixelWidth: pixelSize[0],
+ pixelHeight: pixelSize[1],
+ "renderDiffuse": renderDiffuse,
+ "renderHighlights": renderHighlights,
+ "renderShadows": renderShadows,
+ "renderReflections": renderReflections,
+ "rayDepth": rayDepth
+ }
+ );
+
+ raytracer.renderScene(scene, null, 0);
+ randomException();
+ } catch(e) { }
+}
+
+for (var i = 0; i < 6; ++i)
+ renderScene();
</ins></span></pre></div>
<a id="trunkLayoutTestsjsregressv8raytracewithtrycatchhighfrequencythrowsexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws-expected.txt (0 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws-expected.txt (rev 0)
+++ trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws-expected.txt 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -0,0 +1,10 @@
</span><ins>+JSRegress/v8-raytrace-with-try-catch-high-frequency-throws
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS no exception thrown
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
</ins></span></pre></div>
<a id="trunkLayoutTestsjsregressv8raytracewithtrycatchhighfrequencythrowshtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws.html (0 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws.html (rev 0)
+++ trunk/LayoutTests/js/regress/v8-raytrace-with-try-catch-high-frequency-throws.html 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -0,0 +1,12 @@
</span><ins>+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+<head>
+<script src="../../resources/js-test-pre.js"></script>
+</head>
+<body>
+<script src="../../resources/regress-pre.js"></script>
+<script src="script-tests/v8-raytrace-with-try-catch-high-frequency-throws.js"></script>
+<script src="../../resources/regress-post.js"></script>
+<script src="../../resources/js-test-post.js"></script>
+</body>
+</html>
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -1,3 +1,103 @@
</span><ins>+2016-01-29 Saam barati <sbarati@apple.com>
+
+ Exits from exceptions shouldn't jettison code
+ https://bugs.webkit.org/show_bug.cgi?id=153564
+
+ Reviewed by Geoffrey Garen.
+
+ We create two new exit kinds for exception-handling
+ OSRExits:
+ - ExceptionCheck: an exception check after a C call.
+ - GenericUnwind: an OSR exit executes because it's jumped to from genericUnwind machinery.
+
+ Having these two new exit kinds allows us to remove fields from
+ various OSRExit variants that store booleans indicating
+ if the exit is an exception handler, and if so, what kind
+ of exception handler. Most of this patch is just removing
+ those old fields and adding new equivalent functions.
+
+ This patch also implements the policy that we should never consider jettisoning
+ code from exits that happen from an exception check to an op_catch (it might be worth
+ considering a similar policy for 'throw'). We're choosing this policy because
+ it will almost never be more expensive, in total, to execute the OSR exit than
+ to execute the baseline variant of the code. When an exception is thrown, we do
+ really expensive work, like call through to genericUnwind, and also create an error
+ object with a stack trace. The cost of OSR exiting here is small in comparison to
+ those other operations. And penalizing a CodeBlock for OSR exiting from an exception
+ is silly because the basis of our implementation of exception handling in the
+ upper tiers is to OSR exit on a caught exception. So we used to penalize
+ ourselves for having an implementation that is correct w.r.t our design goals.
+
+ I've verified this hypothesis with on v8-raytrace by adding a new
+ benchmark that throws with very high frequency. Implementing
+ this policy on that benchmark results in about a 4-5% speed up.
+
+ * bytecode/ExitKind.cpp:
+ (JSC::exitKindToString):
+ (JSC::exitKindMayJettison):
+ (JSC::exitKindIsCountable): Deleted.
+ * bytecode/ExitKind.h:
+ * dfg/DFGJITCode.cpp:
+ (JSC::DFG::JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite):
+ * dfg/DFGJITCompiler.cpp:
+ (JSC::DFG::JITCompiler::noticeOSREntry):
+ (JSC::DFG::JITCompiler::appendExceptionHandlingOSRExit):
+ (JSC::DFG::JITCompiler::exceptionCheck):
+ (JSC::DFG::JITCompiler::recordCallSiteAndGenerateExceptionHandlingOSRExitIfNeeded):
+ * dfg/DFGJITCompiler.h:
+ * dfg/DFGOSRExit.cpp:
+ (JSC::DFG::OSRExit::OSRExit):
+ * dfg/DFGOSRExit.h:
+ (JSC::DFG::OSRExit::considerAddingAsFrequentExitSite):
+ * dfg/DFGOSRExitBase.h:
+ (JSC::DFG::OSRExitBase::OSRExitBase):
+ (JSC::DFG::OSRExitBase::isExceptionHandler):
+ (JSC::DFG::OSRExitBase::isGenericUnwindHandler):
+ (JSC::DFG::OSRExitBase::considerAddingAsFrequentExitSite):
+ * dfg/DFGOSRExitCompiler.cpp:
+ * dfg/DFGOSRExitCompiler32_64.cpp:
+ (JSC::DFG::OSRExitCompiler::compileExit):
+ * dfg/DFGOSRExitCompiler64.cpp:
+ (JSC::DFG::OSRExitCompiler::compileExit):
+ * dfg/DFGOSRExitCompilerCommon.cpp:
+ (JSC::DFG::handleExitCounts):
+ (JSC::DFG::osrWriteBarrier):
+ (JSC::DFG::adjustAndJumpToTarget):
+ * dfg/DFGOSRExitCompilerCommon.h:
+ (JSC::DFG::adjustFrameAndStackInOSRExitCompilerThunk):
+ * ftl/FTLCompile.cpp:
+ (JSC::FTL::mmAllocateDataSection):
+ * ftl/FTLExitThunkGenerator.cpp:
+ (JSC::FTL::ExitThunkGenerator::emitThunk):
+ * ftl/FTLJITCode.cpp:
+ (JSC::FTL::JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite):
+ * ftl/FTLLowerDFGToLLVM.cpp:
+ (JSC::FTL::DFG::LowerDFGToLLVM::callCheck):
+ (JSC::FTL::DFG::LowerDFGToLLVM::appendOSRExitArgumentsForPatchpointIfWillCatchException):
+ (JSC::FTL::DFG::LowerDFGToLLVM::appendOSRExit):
+ (JSC::FTL::DFG::LowerDFGToLLVM::blessSpeculation):
+ * ftl/FTLOSRExit.cpp:
+ (JSC::FTL::OSRExitDescriptor::emitOSRExit):
+ (JSC::FTL::OSRExitDescriptor::emitOSRExitLater):
+ (JSC::FTL::OSRExitDescriptor::prepareOSRExitHandle):
+ (JSC::FTL::OSRExit::OSRExit):
+ (JSC::FTL::OSRExit::spillRegistersToSpillSlot):
+ (JSC::FTL::OSRExit::recoverRegistersFromSpillSlot):
+ (JSC::FTL::OSRExit::willArriveAtExitFromIndirectExceptionCheck):
+ (JSC::FTL::OSRExit::willArriveAtOSRExitFromCallOperation):
+ (JSC::FTL::exceptionTypeWillArriveAtOSRExitFromGenericUnwind): Deleted.
+ (JSC::FTL::OSRExit::willArriveAtOSRExitFromGenericUnwind): Deleted.
+ * ftl/FTLOSRExit.h:
+ * ftl/FTLOSRExitCompiler.cpp:
+ (JSC::FTL::compileStub):
+ (JSC::FTL::compileFTLOSRExit):
+ * ftl/FTLPatchpointExceptionHandle.cpp:
+ (JSC::FTL::PatchpointExceptionHandle::scheduleExitCreation):
+ (JSC::FTL::PatchpointExceptionHandle::scheduleExitCreationForUnwind):
+ (JSC::FTL::PatchpointExceptionHandle::PatchpointExceptionHandle):
+ (JSC::FTL::PatchpointExceptionHandle::createHandle):
+ * ftl/FTLPatchpointExceptionHandle.h:
+
</ins><span class="cx"> 2016-01-28 Yusuke Suzuki <utatane.tea@gmail.com>
</span><span class="cx">
</span><span class="cx"> [B3] REGRESSION(r195395): testComplex(64, 128) asserts on Linux with GCC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorebytecodeExitKindcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/bytecode/ExitKind.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/bytecode/ExitKind.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/bytecode/ExitKind.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -84,25 +84,27 @@
</span><span class="cx"> return "WatchdogTimerFired";
</span><span class="cx"> case DebuggerEvent:
</span><span class="cx"> return "DebuggerEvent";
</span><ins>+ case ExceptionCheck:
+ return "ExceptionCheck";
+ case GenericUnwind:
+ return "GenericUnwind";
</ins><span class="cx"> }
</span><span class="cx"> RELEASE_ASSERT_NOT_REACHED();
</span><span class="cx"> return "Unknown";
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool exitKindIsCountable(ExitKind kind)
</del><ins>+bool exitKindMayJettison(ExitKind kind)
</ins><span class="cx"> {
</span><span class="cx"> switch (kind) {
</span><del>- case ExitKindUnset:
- RELEASE_ASSERT_NOT_REACHED();
- case BadType:
- case Uncountable:
- case LoadFromHole: // Already counted directly by the baseline JIT.
- case StoreToHole: // Already counted directly by the baseline JIT.
- case OutOfBounds: // Already counted directly by the baseline JIT.
</del><ins>+ case ExceptionCheck:
+ case GenericUnwind:
</ins><span class="cx"> return false;
</span><span class="cx"> default:
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><ins>+
+ RELEASE_ASSERT_NOT_REACHED();
+ return false;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorebytecodeExitKindh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/bytecode/ExitKind.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/bytecode/ExitKind.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/bytecode/ExitKind.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -53,11 +53,13 @@
</span><span class="cx"> Uncountable, // We exited for none of the above reasons, and we should not count it. Most uses of this should be viewed as a FIXME.
</span><span class="cx"> UncountableInvalidation, // We exited because the code block was invalidated; this means that we've already counted the reasons why the code block was invalidated.
</span><span class="cx"> WatchdogTimerFired, // We exited because we need to service the watchdog timer.
</span><del>- DebuggerEvent // We exited because we need to service the debugger.
</del><ins>+ DebuggerEvent, // We exited because we need to service the debugger.
+ ExceptionCheck, // We exited because a direct exception check showed that we threw an exception from a C call.
+ GenericUnwind, // We exited because a we arrived at this OSR exit from genericUnwind.
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> const char* exitKindToString(ExitKind);
</span><del>-bool exitKindIsCountable(ExitKind);
</del><ins>+bool exitKindMayJettison(ExitKind);
</ins><span class="cx">
</span><span class="cx"> } // namespace JSC
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCode.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCode.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCode.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -90,7 +90,7 @@
</span><span class="cx"> RegisterSet JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock* codeBlock, CallSiteIndex callSiteIndex)
</span><span class="cx"> {
</span><span class="cx"> for (OSRExit& exit : osrExit) {
</span><del>- if (exit.m_isExceptionHandler && exit.m_exceptionHandlerCallSiteIndex.bits() == callSiteIndex.bits()) {
</del><ins>+ if (exit.isExceptionHandler() && exit.m_exceptionHandlerCallSiteIndex.bits() == callSiteIndex.bits()) {
</ins><span class="cx"> Operands<ValueRecovery> valueRecoveries;
</span><span class="cx"> reconstruct(codeBlock, exit.m_codeOrigin, exit.m_streamIndex, valueRecoveries);
</span><span class="cx"> RegisterSet liveAtOSRExit;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -541,11 +541,9 @@
</span><span class="cx"> entry->m_reshufflings.shrinkToFit();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void JITCompiler::appendExceptionHandlingOSRExit(unsigned eventStreamIndex, CodeOrigin opCatchOrigin, HandlerInfo* exceptionHandler, CallSiteIndex callSite, MacroAssembler::JumpList jumpsToFail)
</del><ins>+void JITCompiler::appendExceptionHandlingOSRExit(ExitKind kind, unsigned eventStreamIndex, CodeOrigin opCatchOrigin, HandlerInfo* exceptionHandler, CallSiteIndex callSite, MacroAssembler::JumpList jumpsToFail)
</ins><span class="cx"> {
</span><del>- OSRExit exit(Uncountable, JSValueRegs(), graph().methodOfGettingAValueProfileFor(nullptr), m_speculative.get(), eventStreamIndex);
- exit.m_willArriveAtOSRExitFromGenericUnwind = jumpsToFail.empty(); // If jumps are empty, we're going to jump here from genericUnwind from a child call frame.
- exit.m_isExceptionHandler = true;
</del><ins>+ OSRExit exit(kind, JSValueRegs(), graph().methodOfGettingAValueProfileFor(nullptr), m_speculative.get(), eventStreamIndex);
</ins><span class="cx"> exit.m_codeOrigin = opCatchOrigin;
</span><span class="cx"> exit.m_exceptionHandlerCallSiteIndex = callSite;
</span><span class="cx"> OSRExitCompilationInfo& exitInfo = appendExitInfo(jumpsToFail);
</span><span class="lines">@@ -582,7 +580,7 @@
</span><span class="cx"> unsigned streamIndex = m_speculative->m_outOfLineStreamIndex != UINT_MAX ? m_speculative->m_outOfLineStreamIndex : m_speculative->m_stream->size();
</span><span class="cx"> MacroAssembler::Jump hadException = emitNonPatchableExceptionCheck();
</span><span class="cx"> // We assume here that this is called after callOpeartion()/appendCall() is called.
</span><del>- appendExceptionHandlingOSRExit(streamIndex, opCatchOrigin, exceptionHandler, m_jitCode->common.lastCallSite(), hadException);
</del><ins>+ appendExceptionHandlingOSRExit(ExceptionCheck, streamIndex, opCatchOrigin, exceptionHandler, m_jitCode->common.lastCallSite(), hadException);
</ins><span class="cx"> } else
</span><span class="cx"> m_exceptionChecks.append(emitExceptionCheck());
</span><span class="cx"> }
</span><span class="lines">@@ -594,7 +592,7 @@
</span><span class="cx"> bool willCatchException = m_graph.willCatchExceptionInMachineFrame(callSiteCodeOrigin, opCatchOrigin, exceptionHandler);
</span><span class="cx"> CallSiteIndex callSite = addCallSite(callSiteCodeOrigin);
</span><span class="cx"> if (willCatchException)
</span><del>- appendExceptionHandlingOSRExit(eventStreamIndex, opCatchOrigin, exceptionHandler, callSite);
</del><ins>+ appendExceptionHandlingOSRExit(GenericUnwind, eventStreamIndex, opCatchOrigin, exceptionHandler, callSite);
</ins><span class="cx"> return callSite;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCompilerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -279,7 +279,7 @@
</span><span class="cx"> void linkOSRExits();
</span><span class="cx"> void disassemble(LinkBuffer&);
</span><span class="cx">
</span><del>- void appendExceptionHandlingOSRExit(unsigned eventStreamIndex, CodeOrigin, HandlerInfo* exceptionHandler, CallSiteIndex, MacroAssembler::JumpList jumpsToFail = MacroAssembler::JumpList());
</del><ins>+ void appendExceptionHandlingOSRExit(ExitKind, unsigned eventStreamIndex, CodeOrigin, HandlerInfo* exceptionHandler, CallSiteIndex, MacroAssembler::JumpList jumpsToFail = MacroAssembler::JumpList());
</ins><span class="cx">
</span><span class="cx"> // The dataflow graph currently being generated.
</span><span class="cx"> Graph& m_graph;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -43,7 +43,6 @@
</span><span class="cx"> , m_patchableCodeOffset(0)
</span><span class="cx"> , m_recoveryIndex(recoveryIndex)
</span><span class="cx"> , m_streamIndex(streamIndex)
</span><del>- , m_willArriveAtOSRExitFromGenericUnwind(false)
</del><span class="cx"> {
</span><span class="cx"> bool canExit = jit->m_origin.exitOK;
</span><span class="cx"> if (!canExit && jit->m_currentNode) {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExith"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExit.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExit.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExit.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -100,7 +100,6 @@
</span><span class="cx"> void correctJump(LinkBuffer&);
</span><span class="cx">
</span><span class="cx"> unsigned m_streamIndex;
</span><del>- bool m_willArriveAtOSRExitFromGenericUnwind : 1;
</del><span class="cx"> void considerAddingAsFrequentExitSite(CodeBlock* profiledCodeBlock)
</span><span class="cx"> {
</span><span class="cx"> OSRExitBase::considerAddingAsFrequentExitSite(profiledCodeBlock, ExitFromDFG);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitBaseh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExitBase.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExitBase.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExitBase.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -45,7 +45,6 @@
</span><span class="cx"> , m_count(0)
</span><span class="cx"> , m_codeOrigin(origin)
</span><span class="cx"> , m_codeOriginForExitProfile(originForProfile)
</span><del>- , m_isExceptionHandler(false)
</del><span class="cx"> {
</span><span class="cx"> ASSERT(m_codeOrigin.isSet());
</span><span class="cx"> ASSERT(m_codeOriginForExitProfile.isSet());
</span><span class="lines">@@ -58,8 +57,19 @@
</span><span class="cx"> CodeOrigin m_codeOriginForExitProfile;
</span><span class="cx"> CallSiteIndex m_exceptionHandlerCallSiteIndex;
</span><span class="cx">
</span><del>- bool m_isExceptionHandler : 1;
</del><ins>+ ALWAYS_INLINE bool isExceptionHandler() const
+ {
+ return m_kind == ExceptionCheck || m_kind == GenericUnwind;
+ }
</ins><span class="cx">
</span><ins>+ // True if this exit is used as an exception handler for unwinding. This happens to only be set when
+ // isExceptionHandler is true, but all this actually means is that the OSR exit will assume that the
+ // machine state is as it would be coming out of genericUnwind.
+ ALWAYS_INLINE bool isGenericUnwindHandler() const
+ {
+ return m_kind == GenericUnwind;
+ }
+
</ins><span class="cx"> protected:
</span><span class="cx"> void considerAddingAsFrequentExitSite(CodeBlock* profiledCodeBlock, ExitingJITType jitType)
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -131,8 +131,8 @@
</span><span class="cx"> OSRExit& exit = codeBlock->jitCode()->dfg()->osrExit[exitIndex];
</span><span class="cx">
</span><span class="cx"> if (vm->callFrameForCatch)
</span><del>- ASSERT(exit.m_willArriveAtOSRExitFromGenericUnwind);
- if (exit.m_isExceptionHandler)
</del><ins>+ ASSERT(exit.m_kind == GenericUnwind);
+ if (exit.isExceptionHandler())
</ins><span class="cx"> ASSERT(!!vm->exception());
</span><span class="cx">
</span><span class="cx">
</span><span class="lines">@@ -150,7 +150,7 @@
</span><span class="cx"> CCallHelpers jit(vm, codeBlock);
</span><span class="cx"> OSRExitCompiler exitCompiler(jit);
</span><span class="cx">
</span><del>- if (exit.m_willArriveAtOSRExitFromGenericUnwind) {
</del><ins>+ if (exit.m_kind == GenericUnwind) {
</ins><span class="cx"> // We are acting as a defacto op_catch because we arrive here from genericUnwind().
</span><span class="cx"> // So, we must restore our call frame and stack pointer.
</span><span class="cx"> jit.restoreCalleeSavesFromVMCalleeSavesBuffer();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitCompiler32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -248,7 +248,7 @@
</span><span class="cx"> m_jit.emitRestoreCalleeSaves();
</span><span class="cx"> m_jit.emitSaveCalleeSavesFor(m_jit.baselineCodeBlock());
</span><span class="cx">
</span><del>- if (exit.m_isExceptionHandler)
</del><ins>+ if (exit.isExceptionHandler())
</ins><span class="cx"> m_jit.copyCalleeSavesToVMCalleeSavesBuffer();
</span><span class="cx">
</span><span class="cx"> // Do all data format conversions and store the results into the stack.
</span><span class="lines">@@ -397,7 +397,7 @@
</span><span class="cx"> reifyInlinedCallFrames(m_jit, exit);
</span><span class="cx">
</span><span class="cx"> // And finish.
</span><del>- adjustAndJumpToTarget(m_jit, exit, exit.m_isExceptionHandler);
</del><ins>+ adjustAndJumpToTarget(m_jit, exit);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } } // namespace JSC::DFG
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitCompiler64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -261,7 +261,7 @@
</span><span class="cx"> // The tag registers are needed to materialize recoveries below.
</span><span class="cx"> m_jit.emitMaterializeTagCheckRegisters();
</span><span class="cx">
</span><del>- if (exit.m_isExceptionHandler)
</del><ins>+ if (exit.isExceptionHandler())
</ins><span class="cx"> m_jit.copyCalleeSavesToVMCalleeSavesBuffer();
</span><span class="cx">
</span><span class="cx"> // Do all data format conversions and store the results into the stack.
</span><span class="lines">@@ -387,7 +387,7 @@
</span><span class="cx"> reifyInlinedCallFrames(m_jit, exit);
</span><span class="cx">
</span><span class="cx"> // And finish.
</span><del>- adjustAndJumpToTarget(m_jit, exit, exit.m_isExceptionHandler);
</del><ins>+ adjustAndJumpToTarget(m_jit, exit);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } } // namespace JSC::DFG
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitCompilerCommoncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -39,6 +39,9 @@
</span><span class="cx"> void handleExitCounts(CCallHelpers& jit, const OSRExitBase& exit)
</span><span class="cx"> {
</span><span class="cx"> jit.add32(AssemblyHelpers::TrustedImm32(1), AssemblyHelpers::AbsoluteAddress(&exit.m_count));
</span><ins>+
+ if (!exitKindMayJettison(exit.m_kind))
+ return;
</ins><span class="cx">
</span><span class="cx"> jit.move(AssemblyHelpers::TrustedImmPtr(jit.codeBlock()), GPRInfo::regT0);
</span><span class="cx">
</span><span class="lines">@@ -264,7 +267,7 @@
</span><span class="cx"> ownerIsRememberedOrInEden.link(&jit);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void adjustAndJumpToTarget(CCallHelpers& jit, const OSRExitBase& exit, bool isExitingToOpCatch)
</del><ins>+void adjustAndJumpToTarget(CCallHelpers& jit, const OSRExitBase& exit)
</ins><span class="cx"> {
</span><span class="cx"> jit.move(
</span><span class="cx"> AssemblyHelpers::TrustedImmPtr(
</span><span class="lines">@@ -302,7 +305,7 @@
</span><span class="cx"> void* jumpTarget = codeBlockForExit->jitCode()->executableAddressAtOffset(mapping->m_machineCodeOffset);
</span><span class="cx">
</span><span class="cx"> jit.addPtr(AssemblyHelpers::TrustedImm32(JIT::stackPointerOffsetFor(codeBlockForExit) * sizeof(Register)), GPRInfo::callFrameRegister, AssemblyHelpers::stackPointerRegister);
</span><del>- if (isExitingToOpCatch) {
</del><ins>+ if (exit.isExceptionHandler()) {
</ins><span class="cx"> // Since we're jumping to op_catch, we need to set callFrameForCatch.
</span><span class="cx"> jit.storePtr(GPRInfo::callFrameRegister, jit.vm()->addressOfCallFrameForCatch());
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSRExitCompilerCommonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -39,7 +39,7 @@
</span><span class="cx">
</span><span class="cx"> void handleExitCounts(CCallHelpers&, const OSRExitBase&);
</span><span class="cx"> void reifyInlinedCallFrames(CCallHelpers&, const OSRExitBase&);
</span><del>-void adjustAndJumpToTarget(CCallHelpers&, const OSRExitBase&, bool isExitingToOpCatch);
</del><ins>+void adjustAndJumpToTarget(CCallHelpers&, const OSRExitBase&);
</ins><span class="cx">
</span><span class="cx"> template <typename JITCodeType>
</span><span class="cx"> void adjustFrameAndStackInOSRExitCompilerThunk(MacroAssembler& jit, VM* vm, JITCode::JITType jitType)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLCompilecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLCompile.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLCompile.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLCompile.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -492,7 +492,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> OSRExitDescriptorImpl& exitDescriptorImpl = state.osrExitDescriptorImpls[i];
</span><del>- if (exceptionTypeWillArriveAtOSRExitFromGenericUnwind(exitDescriptorImpl.m_exceptionType))
</del><ins>+ if (exitDescriptorImpl.m_kind == GenericUnwind)
</ins><span class="cx"> genericUnwindOSRExitDescriptors.add(exitDescriptor, &exitDescriptorImpl);
</span><span class="cx">
</span><span class="cx"> for (unsigned j = exitDescriptor->m_values.size(); j--;)
</span><span class="lines">@@ -503,7 +503,7 @@
</span><span class="cx"> for (unsigned j = 0; j < iter->value.size(); j++) {
</span><span class="cx"> {
</span><span class="cx"> uint32_t stackmapRecordIndex = iter->value[j].index;
</span><del>- OSRExit exit(exitDescriptor, exitDescriptorImpl, stackmapRecordIndex);
</del><ins>+ OSRExit exit(exitDescriptor, exitDescriptorImpl.m_kind, exitDescriptorImpl, stackmapRecordIndex);
</ins><span class="cx"> state.jitCode->osrExit.append(exit);
</span><span class="cx"> state.finalizer->osrExit.append(OSRExitCompilationInfo());
</span><span class="cx"> }
</span><span class="lines">@@ -528,7 +528,7 @@
</span><span class="cx"> // and the other that will be arrived at from the callOperation exception handler path.
</span><span class="cx"> // This code here generates the second callOperation variant.
</span><span class="cx"> uint32_t stackmapRecordIndex = iter->value[j].index;
</span><del>- OSRExit exit(exitDescriptor, exitDescriptorImpl, stackmapRecordIndex);
</del><ins>+ OSRExit exit(exitDescriptor, ExceptionCheck, exitDescriptorImpl, stackmapRecordIndex);
</ins><span class="cx"> if (exitDescriptorImpl.m_exceptionType == ExceptionType::GetById)
</span><span class="cx"> exit.m_exceptionType = ExceptionType::GetByIdCallOperation;
</span><span class="cx"> else
</span><span class="lines">@@ -590,7 +590,7 @@
</span><span class="cx"> info.m_thunkAddress = linkBuffer->locationOf(info.m_thunkLabel);
</span><span class="cx"> exit.m_patchableCodeOffset = linkBuffer->offsetOf(info.m_thunkJump);
</span><span class="cx">
</span><del>- if (exit.willArriveAtOSRExitFromGenericUnwind()) {
</del><ins>+ if (exit.isGenericUnwindHandler()) {
</ins><span class="cx"> HandlerInfo newHandler = genericUnwindOSRExitDescriptors.get(exit.m_descriptor)->m_baselineExceptionHandler;
</span><span class="cx"> newHandler.start = exit.m_exceptionHandlerCallSiteIndex.bits();
</span><span class="cx"> newHandler.end = exit.m_exceptionHandlerCallSiteIndex.bits() + 1;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLExitThunkGeneratorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLExitThunkGenerator.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLExitThunkGenerator.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLExitThunkGenerator.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -49,7 +49,7 @@
</span><span class="cx"> void ExitThunkGenerator::emitThunk(unsigned index)
</span><span class="cx"> {
</span><span class="cx"> OSRExit& exit = m_state.jitCode->osrExit[index];
</span><del>- ASSERT_UNUSED(exit, !(exit.willArriveAtOSRExitFromGenericUnwind() && exit.willArriveAtOSRExitFromCallOperation()));
</del><ins>+ ASSERT_UNUSED(exit, !(exit.isGenericUnwindHandler() && exit.willArriveAtOSRExitFromCallOperation()));
</ins><span class="cx">
</span><span class="cx"> OSRExitCompilationInfo& info = m_state.finalizer->osrExit[index];
</span><span class="cx"> info.m_thunkLabel = label();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLJITCodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLJITCode.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLJITCode.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLJITCode.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -170,15 +170,15 @@
</span><span class="cx"> #if FTL_USES_B3
</span><span class="cx"> for (OSRExit& exit : osrExit) {
</span><span class="cx"> if (exit.m_exceptionHandlerCallSiteIndex.bits() == callSiteIndex.bits()) {
</span><del>- RELEASE_ASSERT(exit.m_isExceptionHandler);
- RELEASE_ASSERT(exit.m_isUnwindHandler);
</del><ins>+ RELEASE_ASSERT(exit.isExceptionHandler());
+ RELEASE_ASSERT(exit.isGenericUnwindHandler());
</ins><span class="cx"> return ValueRep::usedRegisters(exit.m_valueReps);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> #else // FTL_USES_B3
</span><span class="cx"> for (OSRExit& exit : osrExit) {
</span><span class="cx"> if (exit.m_exceptionHandlerCallSiteIndex.bits() == callSiteIndex.bits()) {
</span><del>- RELEASE_ASSERT(exit.m_isExceptionHandler);
</del><ins>+ RELEASE_ASSERT(exit.isExceptionHandler());
</ins><span class="cx"> return stackmaps.records[exit.m_stackmapRecordIndex].usedRegisterSet();
</span><span class="cx"> }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLLowerDFGToLLVMcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -10186,7 +10186,7 @@
</span><span class="cx"> bool exitOK = true;
</span><span class="cx"> bool isExceptionHandler = true;
</span><span class="cx"> appendOSRExit(
</span><del>- Uncountable, noValue(), nullptr, hadException,
</del><ins>+ ExceptionCheck, noValue(), nullptr, hadException,
</ins><span class="cx"> m_origin.withForExitAndExitOK(opCatchOrigin, exitOK), isExceptionHandler);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -10244,7 +10244,22 @@
</span><span class="cx"> if (!willCatchException)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- appendOSRExitDescriptor(Uncountable, exceptionType, noValue(), nullptr, m_origin.withForExitAndExitOK(opCatchOrigin, true));
</del><ins>+ ExitKind exitKind;
+ switch (exceptionType) {
+ case ExceptionType::JSCall:
+ case ExceptionType::GetById:
+ case ExceptionType::PutById:
+ exitKind = GenericUnwind;
+ break;
+ case ExceptionType::LazySlowPath:
+ case ExceptionType::BinaryOpGenerator:
+ exitKind = ExceptionCheck;
+ break;
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+
+ appendOSRExitDescriptor(exitKind, exceptionType, noValue(), nullptr, m_origin.withForExitAndExitOK(opCatchOrigin, true));
</ins><span class="cx"> OSRExitDescriptor* exitDescriptor = &m_ftlState.jitCode->osrExitDescriptors.last();
</span><span class="cx"> exitDescriptor->m_stackmapID = m_stackmapIDs - 1;
</span><span class="cx">
</span><span class="lines">@@ -10320,7 +10335,7 @@
</span><span class="cx">
</span><span class="cx"> #if FTL_USES_B3
</span><span class="cx"> blessSpeculation(
</span><del>- m_out.speculate(failCondition), kind, lowValue, highValue, origin, isExceptionHandler);
</del><ins>+ m_out.speculate(failCondition), kind, lowValue, highValue, origin);
</ins><span class="cx"> #else // FTL_USES_B3
</span><span class="cx"> OSRExitDescriptor* exitDescriptor = appendOSRExitDescriptor(kind, isExceptionHandler ? ExceptionType::CCallException : ExceptionType::None, lowValue, highValue, origin);
</span><span class="cx">
</span><span class="lines">@@ -10348,7 +10363,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if FTL_USES_B3
</span><del>- void blessSpeculation(CheckValue* value, ExitKind kind, FormattedValue lowValue, Node* highValue, NodeOrigin origin, bool isExceptionHandler = false)
</del><ins>+ void blessSpeculation(CheckValue* value, ExitKind kind, FormattedValue lowValue, Node* highValue, NodeOrigin origin)
</ins><span class="cx"> {
</span><span class="cx"> OSRExitDescriptor* exitDescriptor = appendOSRExitDescriptor(lowValue, highValue);
</span><span class="cx">
</span><span class="lines">@@ -10358,7 +10373,7 @@
</span><span class="cx"> value->setGenerator(
</span><span class="cx"> [=] (CCallHelpers& jit, const B3::StackmapGenerationParams& params) {
</span><span class="cx"> exitDescriptor->emitOSRExit(
</span><del>- *state, kind, origin, jit, params, 0, isExceptionHandler);
</del><ins>+ *state, kind, origin, jit, params, 0);
</ins><span class="cx"> });
</span><span class="cx"> }
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOSRExitcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOSRExit.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOSRExit.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLOSRExit.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -69,20 +69,20 @@
</span><span class="cx"> #if FTL_USES_B3
</span><span class="cx"> RefPtr<OSRExitHandle> OSRExitDescriptor::emitOSRExit(
</span><span class="cx"> State& state, ExitKind exitKind, const NodeOrigin& nodeOrigin, CCallHelpers& jit,
</span><del>- const StackmapGenerationParams& params, unsigned offset, bool isExceptionHandler)
</del><ins>+ const StackmapGenerationParams& params, unsigned offset)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<OSRExitHandle> handle =
</span><del>- prepareOSRExitHandle(state, exitKind, nodeOrigin, params, offset, isExceptionHandler);
</del><ins>+ prepareOSRExitHandle(state, exitKind, nodeOrigin, params, offset);
</ins><span class="cx"> handle->emitExitThunk(state, jit);
</span><span class="cx"> return handle;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<OSRExitHandle> OSRExitDescriptor::emitOSRExitLater(
</span><span class="cx"> State& state, ExitKind exitKind, const NodeOrigin& nodeOrigin,
</span><del>- const StackmapGenerationParams& params, unsigned offset, bool isExceptionHandler)
</del><ins>+ const StackmapGenerationParams& params, unsigned offset)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<OSRExitHandle> handle =
</span><del>- prepareOSRExitHandle(state, exitKind, nodeOrigin, params, offset, isExceptionHandler);
</del><ins>+ prepareOSRExitHandle(state, exitKind, nodeOrigin, params, offset);
</ins><span class="cx"> params.addLatePath(
</span><span class="cx"> [handle, &state] (CCallHelpers& jit) {
</span><span class="cx"> handle->emitExitThunk(state, jit);
</span><span class="lines">@@ -92,11 +92,11 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<OSRExitHandle> OSRExitDescriptor::prepareOSRExitHandle(
</span><span class="cx"> State& state, ExitKind exitKind, const NodeOrigin& nodeOrigin,
</span><del>- const StackmapGenerationParams& params, unsigned offset, bool isExceptionHandler)
</del><ins>+ const StackmapGenerationParams& params, unsigned offset)
</ins><span class="cx"> {
</span><span class="cx"> unsigned index = state.jitCode->osrExit.size();
</span><span class="cx"> OSRExit& exit = state.jitCode->osrExit.alloc(
</span><del>- this, exitKind, nodeOrigin.forExit, nodeOrigin.semantic, isExceptionHandler);
</del><ins>+ this, exitKind, nodeOrigin.forExit, nodeOrigin.semantic);
</ins><span class="cx"> RefPtr<OSRExitHandle> handle = adoptRef(new OSRExitHandle(index, exit));
</span><span class="cx"> for (unsigned i = offset; i < params.size(); ++i)
</span><span class="cx"> exit.m_valueReps.append(params[i]);
</span><span class="lines">@@ -108,23 +108,20 @@
</span><span class="cx"> #if FTL_USES_B3
</span><span class="cx"> OSRExit::OSRExit(
</span><span class="cx"> OSRExitDescriptor* descriptor,
</span><del>- ExitKind exitKind, CodeOrigin codeOrigin, CodeOrigin codeOriginForExitProfile,
- bool isExceptionHandler)
</del><ins>+ ExitKind exitKind, CodeOrigin codeOrigin, CodeOrigin codeOriginForExitProfile)
</ins><span class="cx"> : OSRExitBase(exitKind, codeOrigin, codeOriginForExitProfile)
</span><span class="cx"> , m_descriptor(descriptor)
</span><span class="cx"> {
</span><del>- m_isExceptionHandler = isExceptionHandler;
</del><span class="cx"> }
</span><span class="cx"> #else // FTL_USES_B3
</span><span class="cx"> OSRExit::OSRExit(
</span><del>- OSRExitDescriptor* descriptor, OSRExitDescriptorImpl& exitDescriptorImpl,
</del><ins>+ OSRExitDescriptor* descriptor, ExitKind exitKind, OSRExitDescriptorImpl& exitDescriptorImpl,
</ins><span class="cx"> uint32_t stackmapRecordIndex)
</span><del>- : OSRExitBase(exitDescriptorImpl.m_kind, exitDescriptorImpl.m_codeOrigin, exitDescriptorImpl.m_codeOriginForExitProfile)
</del><ins>+ : OSRExitBase(exitKind, exitDescriptorImpl.m_codeOrigin, exitDescriptorImpl.m_codeOriginForExitProfile)
</ins><span class="cx"> , m_descriptor(descriptor)
</span><span class="cx"> , m_stackmapRecordIndex(stackmapRecordIndex)
</span><span class="cx"> , m_exceptionType(exitDescriptorImpl.m_exceptionType)
</span><span class="cx"> {
</span><del>- m_isExceptionHandler = exitDescriptorImpl.m_exceptionType != ExceptionType::None;
</del><span class="cx"> }
</span><span class="cx"> #endif // FTL_USES_B3
</span><span class="cx">
</span><span class="lines">@@ -178,7 +175,7 @@
</span><span class="cx">
</span><span class="cx"> void OSRExit::spillRegistersToSpillSlot(CCallHelpers& jit, int32_t stackSpillSlot)
</span><span class="cx"> {
</span><del>- RELEASE_ASSERT(willArriveAtOSRExitFromGenericUnwind() || willArriveAtOSRExitFromCallOperation());
</del><ins>+ RELEASE_ASSERT(isGenericUnwindHandler() || willArriveAtOSRExitFromCallOperation());
</ins><span class="cx"> unsigned count = 0;
</span><span class="cx"> for (GPRReg reg = MacroAssembler::firstRegister(); reg <= MacroAssembler::lastRegister(); reg = MacroAssembler::nextRegister(reg)) {
</span><span class="cx"> if (registersToPreserveForCallThatMightThrow.get(reg)) {
</span><span class="lines">@@ -196,7 +193,7 @@
</span><span class="cx">
</span><span class="cx"> void OSRExit::recoverRegistersFromSpillSlot(CCallHelpers& jit, int32_t stackSpillSlot)
</span><span class="cx"> {
</span><del>- RELEASE_ASSERT(willArriveAtOSRExitFromGenericUnwind() || willArriveAtOSRExitFromCallOperation());
</del><ins>+ RELEASE_ASSERT(isGenericUnwindHandler() || willArriveAtOSRExitFromCallOperation());
</ins><span class="cx"> unsigned count = 0;
</span><span class="cx"> for (GPRReg reg = MacroAssembler::firstRegister(); reg <= MacroAssembler::lastRegister(); reg = MacroAssembler::nextRegister(reg)) {
</span><span class="cx"> if (registersToPreserveForCallThatMightThrow.get(reg)) {
</span><span class="lines">@@ -229,24 +226,6 @@
</span><span class="cx"> RELEASE_ASSERT_NOT_REACHED();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool exceptionTypeWillArriveAtOSRExitFromGenericUnwind(ExceptionType exceptionType)
-{
- switch (exceptionType) {
- case ExceptionType::JSCall:
- case ExceptionType::GetById:
- case ExceptionType::PutById:
- return true;
- default:
- return false;
- }
- RELEASE_ASSERT_NOT_REACHED();
-}
-
-bool OSRExit::willArriveAtOSRExitFromGenericUnwind() const
-{
- return exceptionTypeWillArriveAtOSRExitFromGenericUnwind(m_exceptionType);
-}
-
</del><span class="cx"> bool OSRExit::willArriveAtOSRExitFromCallOperation() const
</span><span class="cx"> {
</span><span class="cx"> switch (m_exceptionType) {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOSRExith"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOSRExit.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOSRExit.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLOSRExit.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -80,8 +80,6 @@
</span><span class="cx"> LazySlowPath,
</span><span class="cx"> BinaryOpGenerator,
</span><span class="cx"> };
</span><del>-
-bool exceptionTypeWillArriveAtOSRExitFromGenericUnwind(ExceptionType);
</del><span class="cx"> #endif // !FTL_USES_B3
</span><span class="cx">
</span><span class="cx"> struct OSRExitDescriptor {
</span><span class="lines">@@ -116,7 +114,7 @@
</span><span class="cx"> // this call, the OSRExit is simply ready to go.
</span><span class="cx"> RefPtr<OSRExitHandle> emitOSRExit(
</span><span class="cx"> State&, ExitKind, const DFG::NodeOrigin&, CCallHelpers&, const B3::StackmapGenerationParams&,
</span><del>- unsigned offset = 0, bool isExceptionHandler = false);
</del><ins>+ unsigned offset = 0);
</ins><span class="cx">
</span><span class="cx"> // In some cases you want an OSRExit to come into existence, but you don't want to emit it right now.
</span><span class="cx"> // This will emit the OSR exit in a late path. You can't be sure exactly when that will happen, but
</span><span class="lines">@@ -128,14 +126,15 @@
</span><span class="cx"> // eventually gets access to its label.
</span><span class="cx"> RefPtr<OSRExitHandle> emitOSRExitLater(
</span><span class="cx"> State&, ExitKind, const DFG::NodeOrigin&, const B3::StackmapGenerationParams&,
</span><del>- unsigned offset = 0, bool isExceptionHandler = false);
</del><ins>+ unsigned offset = 0);
</ins><span class="cx">
</span><ins>+private:
</ins><span class="cx"> // This is the low-level interface. It will create a handle representing the desire to emit code for
</span><span class="cx"> // an OSR exit. You can call OSRExitHandle::emitExitThunk() once you have a place to emit it. Note
</span><span class="cx"> // that the above two APIs are written in terms of this and OSRExitHandle::emitExitThunk().
</span><span class="cx"> RefPtr<OSRExitHandle> prepareOSRExitHandle(
</span><span class="cx"> State&, ExitKind, const DFG::NodeOrigin&, const B3::StackmapGenerationParams&,
</span><del>- unsigned offset = 0, bool isExceptionHandler = false);
</del><ins>+ unsigned offset = 0);
</ins><span class="cx"> #endif // FTL_USES_B3
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -160,9 +159,9 @@
</span><span class="cx">
</span><span class="cx"> struct OSRExit : public DFG::OSRExitBase {
</span><span class="cx"> OSRExit(
</span><del>- OSRExitDescriptor*,
</del><ins>+ OSRExitDescriptor*, ExitKind,
</ins><span class="cx"> #if FTL_USES_B3
</span><del>- ExitKind, CodeOrigin, CodeOrigin codeOriginForExitProfile, bool isExceptionHandler
</del><ins>+ CodeOrigin, CodeOrigin codeOriginForExitProfile
</ins><span class="cx"> #else // FTL_USES_B3
</span><span class="cx"> OSRExitDescriptorImpl&, uint32_t stackmapRecordIndex
</span><span class="cx"> #endif // FTL_USES_B3
</span><span class="lines">@@ -174,10 +173,6 @@
</span><span class="cx"> // This tells us where to place a jump.
</span><span class="cx"> CodeLocationJump m_patchableJump;
</span><span class="cx"> Vector<B3::ValueRep> m_valueReps;
</span><del>- // True if this exit is used as an exception handler for unwinding. This happens to only be set when
- // isExceptionHandler is true, but all this actually means is that the OSR exit will assume that the
- // machine state is as it would be coming out of genericUnwind.
- bool m_isUnwindHandler { false };
</del><span class="cx"> #else // FTL_USES_B3
</span><span class="cx"> // Offset within the exit stubs of the stub for this exit.
</span><span class="cx"> unsigned m_patchableCodeOffset;
</span><span class="lines">@@ -198,7 +193,6 @@
</span><span class="cx"> void spillRegistersToSpillSlot(CCallHelpers&, int32_t stackSpillSlot);
</span><span class="cx"> void recoverRegistersFromSpillSlot(CCallHelpers& jit, int32_t stackSpillSlot);
</span><span class="cx">
</span><del>- bool willArriveAtOSRExitFromGenericUnwind() const;
</del><span class="cx"> bool willArriveAtExitFromIndirectExceptionCheck() const;
</span><span class="cx"> bool willArriveAtOSRExitFromCallOperation() const;
</span><span class="cx"> bool needsRegisterRecoveryOnGenericUnwindOSRExitPath() const;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOSRExitCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -207,13 +207,7 @@
</span><span class="cx"> CCallHelpers jit(vm, codeBlock);
</span><span class="cx">
</span><span class="cx"> // The first thing we need to do is restablish our frame in the case of an exception.
</span><del>- if (
-#if FTL_USES_B3
- exit.m_isUnwindHandler
-#else // FTL_USES_B3
- exit.willArriveAtOSRExitFromGenericUnwind()
-#endif // FTL_USES_B3
- ) {
</del><ins>+ if (exit.isGenericUnwindHandler()) {
</ins><span class="cx"> RELEASE_ASSERT(vm->callFrameForCatch); // The first time we hit this exit, like at all other times, this field should be non-null.
</span><span class="cx"> jit.restoreCalleeSavesFromVMCalleeSavesBuffer();
</span><span class="cx"> jit.loadPtr(vm->addressOfCallFrameForCatch(), MacroAssembler::framePointerRegister);
</span><span class="lines">@@ -488,19 +482,19 @@
</span><span class="cx"> RegisterAtOffsetList* baselineCalleeSaves = baselineCodeBlock->calleeSaveRegisters();
</span><span class="cx"> RegisterAtOffsetList* vmCalleeSaves = vm->getAllCalleeSaveRegisterOffsets();
</span><span class="cx"> RegisterSet vmCalleeSavesToSkip = RegisterSet::stackRegisters();
</span><del>- if (exit.m_isExceptionHandler)
</del><ins>+ if (exit.isExceptionHandler())
</ins><span class="cx"> jit.move(CCallHelpers::TrustedImmPtr(vm->calleeSaveRegistersBuffer), GPRInfo::regT1);
</span><span class="cx">
</span><span class="cx"> for (Reg reg = Reg::first(); reg <= Reg::last(); reg = reg.next()) {
</span><span class="cx"> if (!allFTLCalleeSaves.get(reg)) {
</span><del>- if (exit.m_isExceptionHandler)
</del><ins>+ if (exit.isExceptionHandler())
</ins><span class="cx"> RELEASE_ASSERT(!vmCalleeSaves->find(reg));
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx"> unsigned unwindIndex = codeBlock->calleeSaveRegisters()->indexOf(reg);
</span><span class="cx"> RegisterAtOffset* baselineRegisterOffset = baselineCalleeSaves->find(reg);
</span><span class="cx"> RegisterAtOffset* vmCalleeSave = nullptr;
</span><del>- if (exit.m_isExceptionHandler)
</del><ins>+ if (exit.isExceptionHandler())
</ins><span class="cx"> vmCalleeSave = vmCalleeSaves->find(reg);
</span><span class="cx">
</span><span class="cx"> if (reg.isGPR()) {
</span><span class="lines">@@ -540,7 +534,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (exit.m_isExceptionHandler) {
</del><ins>+ if (exit.isExceptionHandler()) {
</ins><span class="cx"> RegisterAtOffset* vmCalleeSave = vmCalleeSaves->find(GPRInfo::tagTypeNumberRegister);
</span><span class="cx"> jit.store64(GPRInfo::tagTypeNumberRegister, MacroAssembler::Address(GPRInfo::regT1, vmCalleeSave->offset()));
</span><span class="cx">
</span><span class="lines">@@ -564,7 +558,7 @@
</span><span class="cx">
</span><span class="cx"> handleExitCounts(jit, exit);
</span><span class="cx"> reifyInlinedCallFrames(jit, exit);
</span><del>- adjustAndJumpToTarget(jit, exit, exit.m_isExceptionHandler);
</del><ins>+ adjustAndJumpToTarget(jit, exit);
</ins><span class="cx">
</span><span class="cx"> LinkBuffer patchBuffer(*vm, jit, codeBlock);
</span><span class="cx"> #if FTL_USES_B3
</span><span class="lines">@@ -622,13 +616,11 @@
</span><span class="cx"> dataLog(" Exit stackmap ID: ", exit.m_descriptor->m_stackmapID, "\n");
</span><span class="cx"> #endif // !FTL_USES_B3
</span><span class="cx"> dataLog(" Current call site index: ", exec->callSiteIndex().bits(), "\n");
</span><del>- dataLog(" Exit is exception handler: ", exit.m_isExceptionHandler, "\n");
-#if FTL_USES_B3
- dataLog(" Is unwind handler: ", exit.m_isUnwindHandler, "\n");
-#else // FTL_USES_B3
- dataLog(" Will arrive at exit from genericUnwind(): ", exit.willArriveAtOSRExitFromGenericUnwind(), "\n");
</del><ins>+ dataLog(" Exit is exception handler: ", exit.isExceptionHandler(), "\n");
+ dataLog(" Is unwind handler: ", exit.isGenericUnwindHandler(), "\n");
+#if !FTL_USES_B3
</ins><span class="cx"> dataLog(" Will arrive at exit from lazy slow path: ", exit.m_exceptionType == ExceptionType::LazySlowPath, "\n");
</span><del>-#endif // FTL_USES_B3
</del><ins>+#endif // !FTL_USES_B3
</ins><span class="cx"> dataLog(" Exit values: ", exit.m_descriptor->m_values, "\n");
</span><span class="cx"> #if FTL_USES_B3
</span><span class="cx"> dataLog(" Value reps: ", listDump(exit.m_valueReps), "\n");
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLPatchpointExceptionHandlecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.cpp (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.cpp 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.cpp 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -69,7 +69,7 @@
</span><span class="cx"> new ExceptionTarget(isDefaultHandler, m_state.exceptionHandler, nullptr));
</span><span class="cx"> }
</span><span class="cx"> bool isDefaultHandler = false;
</span><del>- return adoptRef(new ExceptionTarget(isDefaultHandler, { }, createHandle(params)));
</del><ins>+ return adoptRef(new ExceptionTarget(isDefaultHandler, { }, createHandle(ExceptionCheck, params)));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void PatchpointExceptionHandle::scheduleExitCreationForUnwind(
</span><span class="lines">@@ -78,9 +78,8 @@
</span><span class="cx"> if (!m_descriptor)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- RefPtr<OSRExitHandle> handle = createHandle(params);
</del><ins>+ RefPtr<OSRExitHandle> handle = createHandle(GenericUnwind, params);
</ins><span class="cx">
</span><del>- handle->exit.m_isUnwindHandler = true;
</del><span class="cx"> handle->exit.m_exceptionHandlerCallSiteIndex = callSiteIndex;
</span><span class="cx">
</span><span class="cx"> HandlerInfo handler = m_handler;
</span><span class="lines">@@ -110,11 +109,10 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<OSRExitHandle> PatchpointExceptionHandle::createHandle(
</span><del>- const B3::StackmapGenerationParams& params)
</del><ins>+ ExitKind kind, const B3::StackmapGenerationParams& params)
</ins><span class="cx"> {
</span><del>- bool isExceptionHandler = true;
</del><span class="cx"> return m_descriptor->emitOSRExitLater(
</span><del>- m_state, Uncountable, m_origin, params, m_offset, isExceptionHandler);
</del><ins>+ m_state, kind, m_origin, params, m_offset);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } } // namespace JSC::FTL
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLPatchpointExceptionHandleh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.h (195830 => 195831)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.h 2016-01-29 19:19:42 UTC (rev 195830)
+++ trunk/Source/JavaScriptCore/ftl/FTLPatchpointExceptionHandle.h 2016-01-29 19:46:01 UTC (rev 195831)
</span><span class="lines">@@ -31,6 +31,7 @@
</span><span class="cx"> #if ENABLE(FTL_JIT) && FTL_USES_B3
</span><span class="cx">
</span><span class="cx"> #include "DFGNodeOrigin.h"
</span><ins>+#include "ExitKind.h"
</ins><span class="cx"> #include "HandlerInfo.h"
</span><span class="cx"> #include <wtf/Ref.h>
</span><span class="cx"> #include <wtf/ThreadSafeRefCounted.h>
</span><span class="lines">@@ -88,7 +89,7 @@
</span><span class="cx"> PatchpointExceptionHandle(
</span><span class="cx"> State&, OSRExitDescriptor*, DFG::NodeOrigin, unsigned offset, const HandlerInfo&);
</span><span class="cx">
</span><del>- RefPtr<OSRExitHandle> createHandle(const B3::StackmapGenerationParams&);
</del><ins>+ RefPtr<OSRExitHandle> createHandle(ExitKind, const B3::StackmapGenerationParams&);
</ins><span class="cx">
</span><span class="cx"> State& m_state;
</span><span class="cx"> OSRExitDescriptor* m_descriptor;
</span></span></pre>
</div>
</div>
</body>
</html>