<!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>[201783] 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/201783">201783</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2016-06-07 18:43:35 -0700 (Tue, 07 Jun 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Implement Air::allocateStack() in ES6 to see how much of a bad idea that is
https://bugs.webkit.org/show_bug.cgi?id=158318
Reviewed by Saam Barati.
PerformanceTests:
This adds a new benchmark for us to play with called JSAir. It's a complete ES6
implementation of Air's allocateStack() phase along with all of Air needed to run that
phase. This includes things like stack slots, registers, temporaries, basic blocks,
instructions, and all of the code for iterating over, inspecting, and modifying those
things.
To make this work, JSC can now dump Air just before allocateStack() in the form of JS code
that creates a Code object that matches exactly what C++ Air saw. This benchmark comprises
four Air IRs:
- Octane/gbemu's largest function, executeIteration.
- Kraken/imaging-gaussian-blur's largest function in OSR entry mode, gaussuanBlur.
- Octane/typescript's largest function that is actually hot, scanIdentifier.
- JSAir's largest hot function, which is anonymous, so we call it by its hash (ACLj8C).
This runs in about 2 seconds on my machine in JSC trunk. It includes both a commandline
harness and a web harness. JSAir is almost exactly 100x slower in ES6 in WebKit than the
C++ Air::allocateStack() phase on which it is based.
JSAir uses the following ES6 features:
- Symbol.
- for-of.
- arrow functions.
- Map/Set.
- let/const.
- classes.
All of these things are used in anger and should end up on the hot path. There is also code
that uses Proxies, but it ends up being dead.
We can improve this even more:
I still need to add result validation: https://bugs.webkit.org/show_bug.cgi?id=158493
I want to make it use more ES6 features: https://bugs.webkit.org/show_bug.cgi?id=158497
* JSAir: Added.
* JSAir/all.js: Added.
* JSAir/allocate_stack.js: Added.
(allocateStack.attemptAssignment):
(allocateStack.assign):
(allocateStack.interfere):
(allocateStack.):
(allocateStack):
* JSAir/arg.js: Added.
(Arg):
(Arg.isAnyUse):
(Arg.isColdUse):
(Arg.isWarmUse):
(Arg.cooled):
(Arg.isEarlyUse):
(Arg.isLateUse):
(Arg.isAnyDef):
(Arg.isEarlyDef):
(Arg.isLateDef):
(Arg.isZDef):
(Arg.typeForB3Type):
(Arg.widthForB3Type):
(Arg.conservativeWidth):
(Arg.minimumWidth):
(Arg.bytes):
(Arg.widthForBytes):
(Arg.createTmp):
(Arg.fromReg):
(Arg.createImm):
(Arg.createBigImm):
(Arg.createBitImm):
(Arg.createBitImm64):
(Arg.createAddr):
(Arg.createStack):
(Arg.createCallArg):
(Arg.createStackAddr):
(Arg.isValidScale):
(Arg.logScale):
(Arg.createIndex):
(Arg.createRelCond):
(Arg.createResCond):
(Arg.createDoubleCond):
(Arg.createWidth):
(Arg.prototype.get kind):
(Arg.prototype.get isTmp):
(Arg.prototype.get isImm):
(Arg.prototype.get isBigImm):
(Arg.prototype.get isBitImm):
(Arg.prototype.get isBitImm64):
(Arg.prototype.get isSomeImm):
(Arg.prototype.get isAddr):
(Arg.prototype.get isStack):
(Arg.prototype.get isCallArg):
(Arg.prototype.get isIndex):
(Arg.prototype.get isMemory):
(Arg.prototype.get isStackMemory):
(Arg.prototype.get isRelCond):
(Arg.prototype.get isResCond):
(Arg.prototype.get isDoubleCond):
(Arg.prototype.get isCondition):
(Arg.prototype.get isWidth):
(Arg.prototype.get isAlive):
(Arg.prototype.get tmp):
(Arg.prototype.get value):
(Arg.prototype.get base):
(Arg.prototype.get hasOffset):
(Arg.prototype.get offset):
(Arg.prototype.get stackSlot):
(Arg.prototype.get index):
(Arg.prototype.get scale):
(Arg.prototype.get logScale):
(Arg.prototype.get width):
(Arg.prototype.get isGPTmp):
(Arg.prototype.get isFPTmp):
(Arg.prototype.get isGP):
(Arg.prototype.get isFP):
(Arg.prototype.get hasType):
(Arg.prototype.get type):
(Arg.prototype.isType):
(Arg.prototype.isCompatibleType):
(Arg.prototype.get isGPR):
(Arg.prototype.get gpr):
(Arg.prototype.get isFPR):
(Arg.prototype.get fpr):
(Arg.prototype.get isReg):
(Arg.prototype.get reg):
(Arg.isValidImmForm):
(Arg.isValidBitImmForm):
(Arg.isValidBitImm64Form):
(Arg.isValidAddrForm):
(Arg.isValidIndexForm):
(Arg.prototype.isValidForm):
(Arg.prototype.forEachTmpFast):
(Arg.prototype.usesTmp):
(Arg.prototype.forEachTmp):
(Arg.prototype.is):
(Arg.prototype.as):
(Arg.prototype.forEachFast):
(Arg.prototype.forEach):
(Arg.extract):
(Arg.forEachFast):
(Arg.forEach):
(Arg.prototype.get condition):
(Arg.prototype.get isInvertible):
(Arg.prototype.toString):
* JSAir/basic_block.js: Added.
(BasicBlock):
(BasicBlock.prototype.get index):
(BasicBlock.prototype.get size):
(BasicBlock.prototype.Symbol.iterator):
(BasicBlock.prototype.at):
(BasicBlock.get last):
(BasicBlock.get insts):
(BasicBlock.get numSuccessors):
(BasicBlock.get successors):
(BasicBlock.get successorBlocks.):
(BasicBlock.get successorBlocks):
(BasicBlock.set get numPredecessors):
(BasicBlock.get predecessors):
(BasicBlock.get frequency):
(BasicBlock.get headerString):
(BasicBlock.get footerString):
* JSAir/benchmark.js: Added.
(benchmark):
* JSAir/code.js: Added.
(Code):
(Code.prototype.addBlock):
(Code.prototype.addStackSlot):
(Code.prototype.newTmp):
(Code.prototype.get size):
(Code.prototype.at):
(Code.prototype.Symbol.iterator):
(Code.prototype.get blocks):
(Code.prototype.get stackSlots):
(Code.prototype.tmps):
(Code.prototype.get callArgAreaSize):
(Code.prototype.requestCallArgAreaSize):
(Code.prototype.get frameSize):
(Code.prototype.setFrameSize):
(Code.prototype.toString):
* JSAir/custom.js: Added.
(const.ShuffleCustom.forEachArg):
(const.ShuffleCustom.hasNonArgNonControlEffects):
(const.PatchCustom.forEachArg):
(const.PatchCustom.hasNonArgNonControlEffects):
(const.CCallCustom.forEachArg):
(const.CCallCustom.hasNonArgNonControlEffects):
(const.ColdCCallCustom.forEachArg):
(const.ColdCCallCustom.hasNonArgNonControlEffects):
* JSAir/frequented_block.js: Added.
(FrequentedBlock):
(FrequentedBlock.prototype.toString):
* JSAir/insertion_set.js: Added.
(Insertion):
(Insertion.prototype.get index):
(Insertion.prototype.get element):
(Insertion.prototype.lessThan):
(InsertionSet):
(InsertionSet.prototype.appendInsertion):
(InsertionSet.prototype.append):
(InsertionSet.prototype.execute):
* JSAir/inst.js: Added.
(Inst):
(Inst.prototype.append):
(Inst.prototype.clear):
(Inst.prototype.get opcode):
(Inst.prototype.get args):
(Inst.prototype.visitArg):
(Inst.prototype.forEachTmpFast):
(Inst.prototype.forEachArg):
(Inst.prototype.forEachTmp):
(Inst.prototype.forEach):
(Inst.forEachDef):
(Inst.forEachDefWithExtraClobberedRegs):
(Inst.prototype.get hasNonArgEffects):
(Inst.prototype.toString):
* JSAir/liveness.js: Added.
(Liveness):
(Liveness.prototype.get thing):
(Liveness.prototype.get code):
(Liveness.prototype.get liveAtHead):
(Liveness.prototype.get liveAtTail):
(Liveness.prototype.localCalc.LocalCalc):
(Liveness.prototype.localCalc.LocalCalc.prototype.get liveSet):
(Liveness.prototype.localCalc.LocalCalc.prototype.execute):
(Liveness.prototype.localCalc):
* JSAir/opcode.js: Added.
(Inst_forEachArg):
(Inst_hasNonArgEffects):
* JSAir/payload-gbemu-executeIteration.js: Added.
(createPayloadGbemuExecuteIteration):
* JSAir/payload-imaging-gaussian-blur-gaussianBlur.js: Added.
(createPayloadImagingGaussianBlurGaussianBlur):
* JSAir/payload-jsair-ACLj8C.js: Added.
(createPayloadJSAirACLj8C):
* JSAir/payload-typescript-scanIdentifier.js: Added.
(createPayloadTypescriptScanIdentifier):
* JSAir/reg.js: Added.
(Reg):
(Reg.fromReg):
(Reg.prototype.get index):
(Reg.prototype.get type):
(Reg.prototype.get name):
(Reg.prototype.get isCalleeSave):
(Reg.prototype.get isReg):
(Reg.prototype.toString):
(Reg.extract):
(Reg.forEachFast):
(Reg.forEach):
(newGPR):
(Reg.gprs.Reg.fprs.Reg.calleeSaveGPRs.Reg.calleeSaveFPRs.Reg.calleeSaves):
* JSAir/stack_slot.js: Added.
(StackSlot):
(StackSlot.prototype.get byteSize):
(StackSlot.prototype.get kind):
(StackSlot.prototype.get isLocked):
(StackSlot.prototype.get isSpill):
(StackSlot.prototype.get index):
(StackSlot.prototype.ensureSize):
(StackSlot.prototype.get alignment):
(StackSlot.prototype.get offsetFromFP):
(StackSlot.prototype.setOffsetFromFP):
(StackSlot.prototype.toString):
(StackSlot.extract):
(StackSlot.forEachFast):
(StackSlot.forEach):
* JSAir/symbols.js: Added.
* JSAir/test.html: Added.
* JSAir/test.js: Added.
* JSAir/tmp.js: Added.
(Tmp):
(Tmp.fromReg):
(Tmp.prototype.get index):
(Tmp.prototype.get type):
(Tmp.prototype.get isReg):
(Tmp.prototype.toString):
(Tmp.extract):
(Tmp.forEachFast):
(Tmp.forEach):
* JSAir/tmp_base.js: Added.
(TmpBase.prototype.get isGP):
(TmpBase.prototype.get isFP):
(TmpBase.prototype.get isGPR):
(TmpBase.prototype.get isFPR):
(TmpBase.prototype.get reg):
(TmpBase.prototype.get gpr):
(TmpBase.prototype.get fpr):
(TmpBase):
* JSAir/util.js: Added.
(isRepresentableAsInt32):
(addIndexed):
(roundUpToMultipleOf):
(symbolName):
(mergeIntoSet):
(nonEmptyRangesOverlap):
(rangesOverlap):
(removeAllMatching):
(swap):
(bubble):
(bubbleSort):
(currentTime):
(else.currentTime):
Source/JavaScriptCore:
Most of these changes are to support dumpAsJS(). But I also found some duplicate and dead
code while rewriting it to JS.
* CMakeLists.txt:
* JavaScriptCore.xcodeproj/project.pbxproj:
* b3/air/AirAllocateStack.cpp:
* b3/air/AirArg.h:
(JSC::B3::Air::Arg::isSomeImm):
(JSC::B3::Air::Arg::isAddr):
(JSC::B3::Air::Arg::tmpIndex):
(JSC::B3::Air::Arg::isValidImmForm):
(JSC::B3::Air::Arg::withOffset): Deleted. This was dead code.
* b3/air/AirArgInlines.h: It turns out that Inst has a ForEach thing that duplicated some of the logic of ArgThingHelper, so I just made ArgThingHelper more powerful.
(JSC::B3::Air::ArgThingHelper<Arg>::forEach):
(JSC::B3::Air::ArgThingHelper<Reg>::is):
(JSC::B3::Air::ArgThingHelper<Reg>::as):
(JSC::B3::Air::ArgThingHelper<Reg>::forEachFast):
(JSC::B3::Air::ArgThingHelper<Reg>::forEach):
(JSC::B3::Air::Arg::is):
* b3/air/AirDumpAsJS.cpp: Added.
(JSC::B3::Air::dumpAsJS):
* b3/air/AirDumpAsJS.h: Added.
* b3/air/AirFixObviousSpills.cpp:
* b3/air/AirGenerate.cpp:
(JSC::B3::Air::prepareForGeneration):
* b3/air/AirInstInlines.h:
(JSC::B3::Air::Inst::forEach):
(JSC::B3::Air::Inst::extraClobberedRegs):
(JSC::B3::Air::ForEach<Tmp>::forEach): Deleted. This was doing what ArgThingHelper would have done but not as well.
(JSC::B3::Air::ForEach<Arg>::forEach): Deleted.
(JSC::B3::Air::ForEach<Reg>::forEach): Deleted.
* b3/air/AirLogRegisterPressure.cpp:
* b3/air/AirReportUsedRegisters.cpp:
* b3/air/AirSpillEverything.cpp:
* b3/air/opcode_generator.rb: Make this dump opcode.js, which is like what it dumps for C++.
* jit/Reg.cpp:
(JSC::Reg::debugName):
(JSC::Reg::dump):
* jit/Reg.h:
(JSC::Reg::hash):
* jsc.cpp: Fix jsc so that it reports the filename and line number of parser errors.
(dumpException):
* parser/ParserError.h: Make it easier to debug this code.
(WTF::printInternal):
* runtime/Options.h:
Source/WTF:
* wtf/Insertion.h:
(WTF::executeInsertions): I found a bug while rewriting this code in JS.
* wtf/PrintStream.h:
(WTF::PrintStream::print):
(WTF::PrintStream::println): This is useful to have.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkPerformanceTestsChangeLog">trunk/PerformanceTests/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreCMakeListstxt">trunk/Source/JavaScriptCore/CMakeLists.txt</a></li>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj">trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirAllocateStackcpp">trunk/Source/JavaScriptCore/b3/air/AirAllocateStack.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirArgh">trunk/Source/JavaScriptCore/b3/air/AirArg.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirArgInlinesh">trunk/Source/JavaScriptCore/b3/air/AirArgInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirFixObviousSpillscpp">trunk/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirGeneratecpp">trunk/Source/JavaScriptCore/b3/air/AirGenerate.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirInstInlinesh">trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirLogRegisterPressurecpp">trunk/Source/JavaScriptCore/b3/air/AirLogRegisterPressure.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirLowerAfterRegAlloccpp">trunk/Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirReportUsedRegisterscpp">trunk/Source/JavaScriptCore/b3/air/AirReportUsedRegisters.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirSpillEverythingcpp">trunk/Source/JavaScriptCore/b3/air/AirSpillEverything.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airopcode_generatorrb">trunk/Source/JavaScriptCore/b3/air/opcode_generator.rb</a></li>
<li><a href="#trunkSourceJavaScriptCorejitRegcpp">trunk/Source/JavaScriptCore/jit/Reg.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitRegh">trunk/Source/JavaScriptCore/jit/Reg.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejsccpp">trunk/Source/JavaScriptCore/jsc.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreparserParserErrorh">trunk/Source/JavaScriptCore/parser/ParserError.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeOptionsh">trunk/Source/JavaScriptCore/runtime/Options.h</a></li>
<li><a href="#trunkSourceWTFChangeLog">trunk/Source/WTF/ChangeLog</a></li>
<li><a href="#trunkSourceWTFwtfInsertionh">trunk/Source/WTF/wtf/Insertion.h</a></li>
<li><a href="#trunkSourceWTFwtfPrintStreamh">trunk/Source/WTF/wtf/PrintStream.h</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li>trunk/PerformanceTests/JSAir/</li>
<li><a href="#trunkPerformanceTestsJSAiralljs">trunk/PerformanceTests/JSAir/all.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirallocate_stackjs">trunk/PerformanceTests/JSAir/allocate_stack.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirargjs">trunk/PerformanceTests/JSAir/arg.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirbasic_blockjs">trunk/PerformanceTests/JSAir/basic_block.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirbenchmarkjs">trunk/PerformanceTests/JSAir/benchmark.js</a></li>
<li><a href="#trunkPerformanceTestsJSAircodejs">trunk/PerformanceTests/JSAir/code.js</a></li>
<li><a href="#trunkPerformanceTestsJSAircustomjs">trunk/PerformanceTests/JSAir/custom.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirfrequented_blockjs">trunk/PerformanceTests/JSAir/frequented_block.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirinsertion_setjs">trunk/PerformanceTests/JSAir/insertion_set.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirinstjs">trunk/PerformanceTests/JSAir/inst.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirlivenessjs">trunk/PerformanceTests/JSAir/liveness.js</a></li>
<li><a href="#trunkPerformanceTestsJSAiropcodejs">trunk/PerformanceTests/JSAir/opcode.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirpayloadgbemuexecuteIterationjs">trunk/PerformanceTests/JSAir/payload-gbemu-executeIteration.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirpayloadimaginggaussianblurgaussianBlurjs">trunk/PerformanceTests/JSAir/payload-imaging-gaussian-blur-gaussianBlur.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirpayloadjsairACLj8Cjs">trunk/PerformanceTests/JSAir/payload-jsair-ACLj8C.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirpayloadtypescriptscanIdentifierjs">trunk/PerformanceTests/JSAir/payload-typescript-scanIdentifier.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirregjs">trunk/PerformanceTests/JSAir/reg.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirstack_slotjs">trunk/PerformanceTests/JSAir/stack_slot.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirsymbolsjs">trunk/PerformanceTests/JSAir/symbols.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirtesthtml">trunk/PerformanceTests/JSAir/test.html</a></li>
<li><a href="#trunkPerformanceTestsJSAirtestjs">trunk/PerformanceTests/JSAir/test.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirtmpjs">trunk/PerformanceTests/JSAir/tmp.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirtmp_basejs">trunk/PerformanceTests/JSAir/tmp_base.js</a></li>
<li><a href="#trunkPerformanceTestsJSAirutiljs">trunk/PerformanceTests/JSAir/util.js</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirDumpAsJScpp">trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirDumpAsJSh">trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkPerformanceTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/PerformanceTests/ChangeLog (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/ChangeLog 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/PerformanceTests/ChangeLog 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1,3 +1,308 @@
</span><ins>+2016-06-07 Filip Pizlo <fpizlo@apple.com>
+
+ Implement Air::allocateStack() in ES6 to see how much of a bad idea that is
+ https://bugs.webkit.org/show_bug.cgi?id=158318
+
+ Reviewed by Saam Barati.
+
+ This adds a new benchmark for us to play with called JSAir. It's a complete ES6
+ implementation of Air's allocateStack() phase along with all of Air needed to run that
+ phase. This includes things like stack slots, registers, temporaries, basic blocks,
+ instructions, and all of the code for iterating over, inspecting, and modifying those
+ things.
+
+ To make this work, JSC can now dump Air just before allocateStack() in the form of JS code
+ that creates a Code object that matches exactly what C++ Air saw. This benchmark comprises
+ four Air IRs:
+
+ - Octane/gbemu's largest function, executeIteration.
+ - Kraken/imaging-gaussian-blur's largest function in OSR entry mode, gaussuanBlur.
+ - Octane/typescript's largest function that is actually hot, scanIdentifier.
+ - JSAir's largest hot function, which is anonymous, so we call it by its hash (ACLj8C).
+
+ This runs in about 2 seconds on my machine in JSC trunk. It includes both a commandline
+ harness and a web harness. JSAir is almost exactly 100x slower in ES6 in WebKit than the
+ C++ Air::allocateStack() phase on which it is based.
+
+ JSAir uses the following ES6 features:
+
+ - Symbol.
+ - for-of.
+ - arrow functions.
+ - Map/Set.
+ - let/const.
+ - classes.
+
+ All of these things are used in anger and should end up on the hot path. There is also code
+ that uses Proxies, but it ends up being dead.
+
+ We can improve this even more:
+ I still need to add result validation: https://bugs.webkit.org/show_bug.cgi?id=158493
+ I want to make it use more ES6 features: https://bugs.webkit.org/show_bug.cgi?id=158497
+
+ * JSAir: Added.
+ * JSAir/all.js: Added.
+ * JSAir/allocate_stack.js: Added.
+ (allocateStack.attemptAssignment):
+ (allocateStack.assign):
+ (allocateStack.interfere):
+ (allocateStack.):
+ (allocateStack):
+ * JSAir/arg.js: Added.
+ (Arg):
+ (Arg.isAnyUse):
+ (Arg.isColdUse):
+ (Arg.isWarmUse):
+ (Arg.cooled):
+ (Arg.isEarlyUse):
+ (Arg.isLateUse):
+ (Arg.isAnyDef):
+ (Arg.isEarlyDef):
+ (Arg.isLateDef):
+ (Arg.isZDef):
+ (Arg.typeForB3Type):
+ (Arg.widthForB3Type):
+ (Arg.conservativeWidth):
+ (Arg.minimumWidth):
+ (Arg.bytes):
+ (Arg.widthForBytes):
+ (Arg.createTmp):
+ (Arg.fromReg):
+ (Arg.createImm):
+ (Arg.createBigImm):
+ (Arg.createBitImm):
+ (Arg.createBitImm64):
+ (Arg.createAddr):
+ (Arg.createStack):
+ (Arg.createCallArg):
+ (Arg.createStackAddr):
+ (Arg.isValidScale):
+ (Arg.logScale):
+ (Arg.createIndex):
+ (Arg.createRelCond):
+ (Arg.createResCond):
+ (Arg.createDoubleCond):
+ (Arg.createWidth):
+ (Arg.prototype.get kind):
+ (Arg.prototype.get isTmp):
+ (Arg.prototype.get isImm):
+ (Arg.prototype.get isBigImm):
+ (Arg.prototype.get isBitImm):
+ (Arg.prototype.get isBitImm64):
+ (Arg.prototype.get isSomeImm):
+ (Arg.prototype.get isAddr):
+ (Arg.prototype.get isStack):
+ (Arg.prototype.get isCallArg):
+ (Arg.prototype.get isIndex):
+ (Arg.prototype.get isMemory):
+ (Arg.prototype.get isStackMemory):
+ (Arg.prototype.get isRelCond):
+ (Arg.prototype.get isResCond):
+ (Arg.prototype.get isDoubleCond):
+ (Arg.prototype.get isCondition):
+ (Arg.prototype.get isWidth):
+ (Arg.prototype.get isAlive):
+ (Arg.prototype.get tmp):
+ (Arg.prototype.get value):
+ (Arg.prototype.get base):
+ (Arg.prototype.get hasOffset):
+ (Arg.prototype.get offset):
+ (Arg.prototype.get stackSlot):
+ (Arg.prototype.get index):
+ (Arg.prototype.get scale):
+ (Arg.prototype.get logScale):
+ (Arg.prototype.get width):
+ (Arg.prototype.get isGPTmp):
+ (Arg.prototype.get isFPTmp):
+ (Arg.prototype.get isGP):
+ (Arg.prototype.get isFP):
+ (Arg.prototype.get hasType):
+ (Arg.prototype.get type):
+ (Arg.prototype.isType):
+ (Arg.prototype.isCompatibleType):
+ (Arg.prototype.get isGPR):
+ (Arg.prototype.get gpr):
+ (Arg.prototype.get isFPR):
+ (Arg.prototype.get fpr):
+ (Arg.prototype.get isReg):
+ (Arg.prototype.get reg):
+ (Arg.isValidImmForm):
+ (Arg.isValidBitImmForm):
+ (Arg.isValidBitImm64Form):
+ (Arg.isValidAddrForm):
+ (Arg.isValidIndexForm):
+ (Arg.prototype.isValidForm):
+ (Arg.prototype.forEachTmpFast):
+ (Arg.prototype.usesTmp):
+ (Arg.prototype.forEachTmp):
+ (Arg.prototype.is):
+ (Arg.prototype.as):
+ (Arg.prototype.forEachFast):
+ (Arg.prototype.forEach):
+ (Arg.extract):
+ (Arg.forEachFast):
+ (Arg.forEach):
+ (Arg.prototype.get condition):
+ (Arg.prototype.get isInvertible):
+ (Arg.prototype.toString):
+ * JSAir/basic_block.js: Added.
+ (BasicBlock):
+ (BasicBlock.prototype.get index):
+ (BasicBlock.prototype.get size):
+ (BasicBlock.prototype.Symbol.iterator):
+ (BasicBlock.prototype.at):
+ (BasicBlock.get last):
+ (BasicBlock.get insts):
+ (BasicBlock.get numSuccessors):
+ (BasicBlock.get successors):
+ (BasicBlock.get successorBlocks.):
+ (BasicBlock.get successorBlocks):
+ (BasicBlock.set get numPredecessors):
+ (BasicBlock.get predecessors):
+ (BasicBlock.get frequency):
+ (BasicBlock.get headerString):
+ (BasicBlock.get footerString):
+ * JSAir/benchmark.js: Added.
+ (benchmark):
+ * JSAir/code.js: Added.
+ (Code):
+ (Code.prototype.addBlock):
+ (Code.prototype.addStackSlot):
+ (Code.prototype.newTmp):
+ (Code.prototype.get size):
+ (Code.prototype.at):
+ (Code.prototype.Symbol.iterator):
+ (Code.prototype.get blocks):
+ (Code.prototype.get stackSlots):
+ (Code.prototype.tmps):
+ (Code.prototype.get callArgAreaSize):
+ (Code.prototype.requestCallArgAreaSize):
+ (Code.prototype.get frameSize):
+ (Code.prototype.setFrameSize):
+ (Code.prototype.toString):
+ * JSAir/custom.js: Added.
+ (const.ShuffleCustom.forEachArg):
+ (const.ShuffleCustom.hasNonArgNonControlEffects):
+ (const.PatchCustom.forEachArg):
+ (const.PatchCustom.hasNonArgNonControlEffects):
+ (const.CCallCustom.forEachArg):
+ (const.CCallCustom.hasNonArgNonControlEffects):
+ (const.ColdCCallCustom.forEachArg):
+ (const.ColdCCallCustom.hasNonArgNonControlEffects):
+ * JSAir/frequented_block.js: Added.
+ (FrequentedBlock):
+ (FrequentedBlock.prototype.toString):
+ * JSAir/insertion_set.js: Added.
+ (Insertion):
+ (Insertion.prototype.get index):
+ (Insertion.prototype.get element):
+ (Insertion.prototype.lessThan):
+ (InsertionSet):
+ (InsertionSet.prototype.appendInsertion):
+ (InsertionSet.prototype.append):
+ (InsertionSet.prototype.execute):
+ * JSAir/inst.js: Added.
+ (Inst):
+ (Inst.prototype.append):
+ (Inst.prototype.clear):
+ (Inst.prototype.get opcode):
+ (Inst.prototype.get args):
+ (Inst.prototype.visitArg):
+ (Inst.prototype.forEachTmpFast):
+ (Inst.prototype.forEachArg):
+ (Inst.prototype.forEachTmp):
+ (Inst.prototype.forEach):
+ (Inst.forEachDef):
+ (Inst.forEachDefWithExtraClobberedRegs):
+ (Inst.prototype.get hasNonArgEffects):
+ (Inst.prototype.toString):
+ * JSAir/liveness.js: Added.
+ (Liveness):
+ (Liveness.prototype.get thing):
+ (Liveness.prototype.get code):
+ (Liveness.prototype.get liveAtHead):
+ (Liveness.prototype.get liveAtTail):
+ (Liveness.prototype.localCalc.LocalCalc):
+ (Liveness.prototype.localCalc.LocalCalc.prototype.get liveSet):
+ (Liveness.prototype.localCalc.LocalCalc.prototype.execute):
+ (Liveness.prototype.localCalc):
+ * JSAir/opcode.js: Added.
+ (Inst_forEachArg):
+ (Inst_hasNonArgEffects):
+ * JSAir/payload-gbemu-executeIteration.js: Added.
+ (createPayloadGbemuExecuteIteration):
+ * JSAir/payload-imaging-gaussian-blur-gaussianBlur.js: Added.
+ (createPayloadImagingGaussianBlurGaussianBlur):
+ * JSAir/payload-jsair-ACLj8C.js: Added.
+ (createPayloadJSAirACLj8C):
+ * JSAir/payload-typescript-scanIdentifier.js: Added.
+ (createPayloadTypescriptScanIdentifier):
+ * JSAir/reg.js: Added.
+ (Reg):
+ (Reg.fromReg):
+ (Reg.prototype.get index):
+ (Reg.prototype.get type):
+ (Reg.prototype.get name):
+ (Reg.prototype.get isCalleeSave):
+ (Reg.prototype.get isReg):
+ (Reg.prototype.toString):
+ (Reg.extract):
+ (Reg.forEachFast):
+ (Reg.forEach):
+ (newGPR):
+ (Reg.gprs.Reg.fprs.Reg.calleeSaveGPRs.Reg.calleeSaveFPRs.Reg.calleeSaves):
+ * JSAir/stack_slot.js: Added.
+ (StackSlot):
+ (StackSlot.prototype.get byteSize):
+ (StackSlot.prototype.get kind):
+ (StackSlot.prototype.get isLocked):
+ (StackSlot.prototype.get isSpill):
+ (StackSlot.prototype.get index):
+ (StackSlot.prototype.ensureSize):
+ (StackSlot.prototype.get alignment):
+ (StackSlot.prototype.get offsetFromFP):
+ (StackSlot.prototype.setOffsetFromFP):
+ (StackSlot.prototype.toString):
+ (StackSlot.extract):
+ (StackSlot.forEachFast):
+ (StackSlot.forEach):
+ * JSAir/symbols.js: Added.
+ * JSAir/test.html: Added.
+ * JSAir/test.js: Added.
+ * JSAir/tmp.js: Added.
+ (Tmp):
+ (Tmp.fromReg):
+ (Tmp.prototype.get index):
+ (Tmp.prototype.get type):
+ (Tmp.prototype.get isReg):
+ (Tmp.prototype.toString):
+ (Tmp.extract):
+ (Tmp.forEachFast):
+ (Tmp.forEach):
+ * JSAir/tmp_base.js: Added.
+ (TmpBase.prototype.get isGP):
+ (TmpBase.prototype.get isFP):
+ (TmpBase.prototype.get isGPR):
+ (TmpBase.prototype.get isFPR):
+ (TmpBase.prototype.get reg):
+ (TmpBase.prototype.get gpr):
+ (TmpBase.prototype.get fpr):
+ (TmpBase):
+ * JSAir/util.js: Added.
+ (isRepresentableAsInt32):
+ (addIndexed):
+ (roundUpToMultipleOf):
+ (symbolName):
+ (mergeIntoSet):
+ (nonEmptyRangesOverlap):
+ (rangesOverlap):
+ (removeAllMatching):
+ (swap):
+ (bubble):
+ (bubbleSort):
+ (currentTime):
+ (else.currentTime):
+
</ins><span class="cx"> 2016-05-26 Yusuke Suzuki <utatane.tea@gmail.com>
</span><span class="cx">
</span><span class="cx"> [JSC] Allow JSBench to use precise time
</span></span></pre></div>
<a id="trunkPerformanceTestsJSAiralljs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/all.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/all.js (rev 0)
+++ trunk/PerformanceTests/JSAir/all.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,18 @@
</span><ins>+"use strict";
+
+load("symbols.js");
+load("tmp_base.js");
+load("arg.js");
+load("basic_block.js");
+load("code.js");
+load("frequented_block.js");
+load("inst.js");
+load("opcode.js");
+load("reg.js");
+load("stack_slot.js");
+load("tmp.js");
+load("util.js");
+load("custom.js");
+load("liveness.js");
+load("insertion_set.js");
+load("allocate_stack.js");
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirallocate_stackjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/allocate_stack.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/allocate_stack.js (rev 0)
+++ trunk/PerformanceTests/JSAir/allocate_stack.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,253 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+function allocateStack(code)
+{
+ if (code.frameSize)
+ throw new Error("Frame size already determined");
+
+ function attemptAssignment(slot, offsetFromFP, otherSlots)
+ {
+ if (offsetFromFP > 0)
+ throw new Error("Expect negative offset");
+
+ offsetFromFP = -roundUpToMultipleOf(slot.alignment, -offsetFromFP);
+
+ for (let otherSlot of otherSlots) {
+ if (!otherSlot.offsetFromFP)
+ continue;
+ let overlap = rangesOverlap(
+ offsetFromFP,
+ offsetFromFP + slot.byteSize,
+ otherSlot.offsetFromFP,
+ otherSlot.offsetFromFP + otherSlot.byteSize);
+ if (overlap)
+ return false;
+ }
+
+ slot.setOffsetFromFP(offsetFromFP);
+ return true;
+ }
+
+ function assign(slot, otherSlots)
+ {
+ if (attemptAssignment(slot, -slot.byteSize, otherSlots))
+ return;
+
+ for (let otherSlot of otherSlots) {
+ if (!otherSlot.offsetFromFP)
+ continue;
+ if (attemptAssignment(slot, otherSlot.offsetFromFP - slot.byteSize, otherSlots))
+ return;
+ }
+
+ throw new Error("Assignment failed");
+ }
+
+ // Allocate all of the escaped slots in order. This is kind of a crazy algorithm to allow for
+ // the possibility of stack slots being assigned frame offsets before we even get here.
+ let assignedEscapedStackSlots = [];
+ let escapedStackSlotsWorklist = [];
+ for (let slot of code.stackSlots) {
+ if (slot.isLocked) {
+ if (slot.offsetFromFP)
+ assignedEscapedStackSlots.push(slot);
+ else
+ escapedStackSlotsWorklist.push(slot);
+ } else {
+ if (slot.offsetFromFP)
+ throw new Error("Offset already assigned");
+ }
+ }
+
+ // This is a fairly espensive loop, but it's OK because we'll usually only have a handful of
+ // escaped stack slots.
+ while (escapedStackSlotsWorklist.length) {
+ let slot = escapedStackSlotsWorklist.pop();
+ assign(slot, assignedEscapedStackSlots);
+ assignedEscapedStackSlots.push(slot);
+ }
+
+ // Now we handle the spill slots.
+ let liveness = new Liveness(StackSlot, code);
+ let interference = new Map();
+ for (let slot of code.stackSlots)
+ interference.set(slot, new Set());
+ let slots = [];
+
+ for (let block of code) {
+ let localCalc = liveness.localCalc(block);
+
+ function interfere(instIndex)
+ {
+ Inst.forEachDef(
+ StackSlot, block.get(instIndex), block.get(instIndex + 1),
+ (slot, role, type, width) => {
+ if (!slot.isSpill)
+ return;
+
+ for (let otherSlot of localCalc.liveSet) {
+ interference.get(slot).add(otherSlot);
+ interference.get(otherSlot).add(slot);
+ }
+ });
+ }
+
+ for (let instIndex = block.size; instIndex--;) {
+ // Kill dead stores. For simplicity we say that a store is killable if it has only late
+ // defs and those late defs are to things that are dead right now. We only do that
+ // because that's the only kind of dead stack store we will see here.
+ let inst = block.at(instIndex);
+ if (!inst.hasNonArgEffects) {
+ let ok = true;
+ inst.forEachArg((arg, role, type, width) => {
+ if (Arg.isEarlyDef(role)) {
+ ok = false;
+ return;
+ }
+ if (!Arg.isLateDef(role))
+ return;
+ if (!arg.isStack) {
+ ok = false;
+ return;
+ }
+
+ let slot = arg.stackSlot;
+ if (!slot.isSpill) {
+ ok = false;
+ return;
+ }
+
+ if (localCalc.liveSet.has(slot)) {
+ ok = false;
+ return;
+ }
+ });
+ if (ok)
+ inst.clear();
+ }
+
+ interfere(instIndex);
+ localCalc.execute(instIndex);
+ }
+ interfere(-1);
+
+ removeAllMatching(block.insts, inst => inst.opcode == Nop);
+ }
+
+ // Now we assign stack locations. At its heart this algorithm is just first-fit. For each
+ // StackSlot we just want to find the offsetFromFP that is closest to zero while ensuring no
+ // overlap with other StackSlots that this overlaps with.
+ for (let slot of code.stackSlots) {
+ if (slot.offsetFromFP)
+ continue;
+
+ assign(slot, assignedEscapedStackSlots.concat(interference.get(slot)));
+ }
+
+ // Figure out how much stack we're using for stack slots.
+ let frameSizeForStackSlots = 0;
+ for (let slot of code.stackSlots) {
+ frameSizeForStackSlots = Math.max(
+ frameSizeForStackSlots,
+ -slot.offsetFromFP);
+ }
+
+ frameSizeForStackSlots = roundUpToMultipleOf(stackAlignmentBytes, frameSizeForStackSlots);
+
+ // No we need to deduce how much argument area we need.
+ for (let block of code) {
+ for (let inst of block) {
+ for (let arg of inst.args) {
+ if (arg.isCallArg) {
+ // For now, we assume that we use 8 bytes of the call arg. But that's not
+ // such an awesome assumption.
+ // FIXME: https://bugs.webkit.org/show_bug.cgi?id=150454
+ if (arg.offset < 0)
+ throw new Error("Did not expect negative offset for callArg");
+ code.requestCallArgAreaSize(arg.offset + 8);
+ }
+ }
+ }
+ }
+
+ code.setFrameSize(frameSizeForStackSlots + code.callArgAreaSize);
+
+ // Finally transform the code to use Addrs instead of StackSlots. This is a lossless
+ // transformation since we can search the StackSlots array to figure out which StackSlot any
+ // offset-from-FP refers to.
+
+ // FIXME: This may produce addresses that aren't valid if we end up with a ginormous stack frame.
+ // We would have to scavenge for temporaries if this happened. Fortunately, this case will be
+ // extremely rare so we can do crazy things when it arises.
+ // https://bugs.webkit.org/show_bug.cgi?id=152530
+
+ let insertionSet = new InsertionSet();
+ for (let block of code) {
+ for (let instIndex = 0; instIndex < block.size; ++instIndex) {
+ let inst = block.at(instIndex);
+ inst.forEachArg((arg, role, type, width) => {
+ function stackAddr(offset)
+ {
+ return Arg.createStackAddr(offset, code.frameSize, width);
+ }
+
+ switch (arg.kind) {
+ case Arg.Stack: {
+ let slot = arg.stackSlot;
+ if (Arg.isZDef(role)
+ && slot.isSpill
+ && slot.byteSize > Arg.bytes(width)) {
+ // Currently we only handle this simple case because it's the only one
+ // that arises: ZDef's are only 32-bit right now. So, when we hit these
+ // assertions it means that we need to implement those other kinds of
+ // zero fills.
+ if (slot.byteSize != 8) {
+ throw new Error(
+ "Bad spill slot size for ZDef: " + slot.byteSize + ", width is " +
+ width);
+ }
+ if (width != 32)
+ throw new Error("Bad width for ZDef");
+
+ insertionSet.insert(
+ instIndex + 1,
+ new Inst(
+ StoreZero32,
+ [stackAddr(arg.offset + 4 + slot.offsetFromFP)]));
+ }
+ return stackAddr(arg.offset + slot.offsetFromFP);
+ }
+ case Arg.CallArg:
+ return stackAddr(arg.offset - code.frameSize);
+ default:
+ break;
+ }
+ });
+ }
+ insertionSet.execute(block.insts);
+ }
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirargjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/arg.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/arg.js (rev 0)
+++ trunk/PerformanceTests/JSAir/arg.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,925 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Arg {
+ constructor()
+ {
+ this._kind = Arg.Invalid;
+ }
+
+ static isAnyUse(role)
+ {
+ switch (role) {
+ case Arg.Use:
+ case Arg.ColdUse:
+ case Arg.UseDef:
+ case Arg.UseZDef:
+ case Arg.LateUse:
+ case Arg.LateColdUse:
+ case Arg.Scratch:
+ return true;
+ case Arg.Def:
+ case Arg.ZDef:
+ case Arg.UseAddr:
+ case Arg.EarlyDef:
+ return false;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isColdUse(role)
+ {
+ switch (role) {
+ case Arg.ColdUse:
+ case Arg.LateColdUse:
+ return true;
+ case Arg.Use:
+ case Arg.UseDef:
+ case Arg.UseZDef:
+ case Arg.LateUse:
+ case Arg.Def:
+ case Arg.ZDef:
+ case Arg.UseAddr:
+ case Arg.Scratch:
+ case Arg.EarlyDef:
+ return false;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isWarmUse(role)
+ {
+ return Arg.isAnyUse(role) && !Arg.isColdUse(role);
+ }
+
+ static cooled(role)
+ {
+ switch (role) {
+ case Arg.ColdUse:
+ case Arg.LateColdUse:
+ case Arg.UseDef:
+ case Arg.UseZDef:
+ case Arg.Def:
+ case Arg.ZDef:
+ case Arg.UseAddr:
+ case Arg.Scratch:
+ case Arg.EarlyDef:
+ return role;
+ case Arg.Use:
+ return Arg.ColdUse;
+ case Arg.LateUse:
+ return Arg.LateColdUse;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isEarlyUse(role)
+ {
+ switch (role) {
+ case Arg.Use:
+ case Arg.ColdUse:
+ case Arg.UseDef:
+ case Arg.UseZDef:
+ return true;
+ case Arg.Def:
+ case Arg.ZDef:
+ case Arg.UseAddr:
+ case Arg.LateUse:
+ case Arg.LateColdUse:
+ case Arg.Scratch:
+ case Arg.EarlyDef:
+ return false;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isLateUse(role)
+ {
+ switch (role) {
+ case Arg.LateUse:
+ case Arg.LateColdUse:
+ case Arg.Scratch:
+ return true;
+ case Arg.ColdUse:
+ case Arg.Use:
+ case Arg.UseDef:
+ case Arg.UseZDef:
+ case Arg.Def:
+ case Arg.ZDef:
+ case Arg.UseAddr:
+ case Arg.EarlyDef:
+ return false;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isAnyDef(role)
+ {
+ switch (role) {
+ case Arg.Use:
+ case Arg.ColdUse:
+ case Arg.UseAddr:
+ case Arg.LateUse:
+ case Arg.LateColdUse:
+ return false;
+ case Arg.Def:
+ case Arg.UseDef:
+ case Arg.ZDef:
+ case Arg.UseZDef:
+ case Arg.EarlyDef:
+ case Arg.Scratch:
+ return true;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isEarlyDef(role)
+ {
+ switch (role) {
+ case Arg.Use:
+ case Arg.ColdUse:
+ case Arg.UseAddr:
+ case Arg.LateUse:
+ case Arg.Def:
+ case Arg.UseDef:
+ case Arg.ZDef:
+ case Arg.UseZDef:
+ case Arg.LateColdUse:
+ return false;
+ case Arg.EarlyDef:
+ case Arg.Scratch:
+ return true;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isLateDef(role)
+ {
+ switch (role) {
+ case Arg.Use:
+ case Arg.ColdUse:
+ case Arg.UseAddr:
+ case Arg.LateUse:
+ case Arg.EarlyDef:
+ case Arg.Scratch:
+ case Arg.LateColdUse:
+ return false;
+ case Arg.Def:
+ case Arg.UseDef:
+ case Arg.ZDef:
+ case Arg.UseZDef:
+ return true;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static isZDef(role)
+ {
+ switch (role) {
+ case Arg.Use:
+ case Arg.ColdUse:
+ case Arg.UseAddr:
+ case Arg.LateUse:
+ case Arg.Def:
+ case Arg.UseDef:
+ case Arg.EarlyDef:
+ case Arg.Scratch:
+ case Arg.LateColdUse:
+ return false;
+ case Arg.ZDef:
+ case Arg.UseZDef:
+ return true;
+ default:
+ throw new Error("Bad role");
+ }
+ }
+
+ static typeForB3Type(type)
+ {
+ switch (type) {
+ case Int32:
+ case Int64:
+ return GP;
+ case Float:
+ case Double:
+ return FP;
+ default:
+ throw new Error("Bad B3 type");
+ }
+ }
+
+ static widthForB3Type(type)
+ {
+ switch (type) {
+ case Int32:
+ case Float:
+ return 32;
+ case Int64:
+ case Double:
+ return 64;
+ default:
+ throw new Error("Bad B3 type");
+ }
+ }
+
+ static conservativeWidth(type)
+ {
+ return type == GP ? Ptr : 64;
+ }
+
+ static minimumWidth(type)
+ {
+ return type == GP ? 8 : 32;
+ }
+
+ static bytes(width)
+ {
+ return width / 8;
+ }
+
+ static widthForBytes(bytes)
+ {
+ switch (bytes) {
+ case 0:
+ case 1:
+ return 8;
+ case 2:
+ return 16;
+ case 3:
+ case 4:
+ return 32;
+ default:
+ if (bytes > 8)
+ throw new Error("Bad number of bytes");
+ return 64;
+ }
+ }
+
+ static createTmp(tmp)
+ {
+ let result = new Arg();
+ result._kind = Arg.Tmp;
+ result._tmp = tmp;
+ return result;
+ }
+
+ static fromReg(reg)
+ {
+ return Arg.createTmp(reg);
+ }
+
+ static createImm(value)
+ {
+ let result = new Arg();
+ result._kind = Arg.Imm;
+ result._value = value;
+ return result;
+ }
+
+ static createBigImm(value)
+ {
+ let result = new Arg();
+ result._kind = Arg.BigImm;
+ result._value = value;
+ return result;
+ }
+
+ static createBitImm(value)
+ {
+ let result = new Arg();
+ result._kind = Arg.BitImm;
+ result._value = value;
+ return result;
+ }
+
+ static createBitImm64(value)
+ {
+ let result = new Arg();
+ result._kind = Arg.BitImm64;
+ result._value = value;
+ return result;
+ }
+
+ static createAddr(base, offset)
+ {
+ if (offset == null)
+ offset = 0;
+ let result = new Arg();
+ result._kind = Arg.Addr;
+ result._base = base;
+ result._offset = offset;
+ return result;
+ }
+
+ static createStack(slot, offset)
+ {
+ if (offset == null)
+ offset = 0;
+ let result = new Arg();
+ result._kind = Arg.Stack;
+ result._slot = slot;
+ result._offset = offset;
+ return result;
+ }
+
+ static createCallArg(offset)
+ {
+ let result = new Arg();
+ result._kind = Arg.CallArg;
+ result._offset = offset;
+ return result;
+ }
+
+ static createStackAddr(offsetFromFP, frameSize, width)
+ {
+ let result = Arg.createAddr(Reg.callFrameRegister, offsetFromFP);
+ if (!result.isValidForm(width))
+ result = Arg.createAddr(Reg.stackPointerRegister, offsetFromFP + frameSize);
+ return result;
+ }
+
+ static isValidScale(scale, width)
+ {
+ switch (scale) {
+ case 1:
+ case 2:
+ case 4:
+ case 8:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ static logScale(scale)
+ {
+ switch (scale) {
+ case 1:
+ return 0;
+ case 2:
+ return 1;
+ case 4:
+ return 2;
+ case 8:
+ return 3;
+ default:
+ throw new Error("Bad scale");
+ }
+ }
+
+ static createIndex(base, index, scale, offset)
+ {
+ if (scale == null)
+ scale = 1;
+ if (offset == null)
+ offset = 0;
+ let result = new Arg();
+ result._kind = Arg.Index;
+ result._base = base;
+ result._index = index;
+ result._scale = scale;
+ result._offset = offset;
+ return result;
+ }
+
+ static createRelCond(condition)
+ {
+ let result = new Arg();
+ result._kind = Arg.RelCond;
+ result._condition = condition;
+ return result;
+ }
+
+ static createResCond(condition)
+ {
+ let result = new Arg();
+ result._kind = Arg.ResCond;
+ result._condition = condition;
+ return result;
+ }
+
+ static createDoubleCond(condition)
+ {
+ let result = new Arg();
+ result._kind = Arg.DoubleCond;
+ result._condition = condition;
+ return result;
+ }
+
+ static createWidth(width)
+ {
+ let result = new Arg();
+ result._kind = Arg.Width;
+ result._width = width;
+ return result;
+ }
+
+ get kind() { return this._kind; }
+ get isTmp() { return this._kind == Arg.Tmp; }
+ get isImm() { return this._kind == Arg.Imm; }
+ get isBigImm() { return this._kind == Arg.BigImm; }
+ get isBitImm() { return this._kind == Arg.BitImm; }
+ get isBitImm64() { return this._kind == Arg.BitImm64; }
+ get isSomeImm()
+ {
+ switch (this._kind) {
+ case Arg.Imm:
+ case Arg.BigImm:
+ case Arg.BitImm:
+ case Arg.BitImm64:
+ return true;
+ default:
+ return false;
+ }
+ }
+ get isAddr() { return this._kind == Arg.Addr; }
+ get isStack() { return this._kind == Arg.Stack; }
+ get isCallArg() { return this._kind == Arg.CallArg; }
+ get isIndex() { return this._kind == Arg.Index; }
+ get isMemory()
+ {
+ switch (this._kind) {
+ case Arg.Addr:
+ case Arg.Stack:
+ case Arg.CallArg:
+ case Arg.Index:
+ return true;
+ default:
+ return false;
+ }
+ }
+ get isStackMemory()
+ {
+ switch (this._kind) {
+ case Arg.Addr:
+ return this._base == Reg.callFrameRegister
+ || this._base == Reg.stackPointerRegister;
+ case Arg.Stack:
+ case Arg.CallArg:
+ return true;
+ default:
+ return false;
+ }
+ }
+ get isRelCond() { return this._kind == Arg.RelCond; }
+ get isResCond() { return this._kind == Arg.ResCond; }
+ get isDoubleCond() { return this._kind == Arg.DoubleCond; }
+ get isCondition()
+ {
+ switch (this._kind) {
+ case Arg.RelCond:
+ case Arg.ResCond:
+ case Arg.DoubleCond:
+ return true;
+ default:
+ return false;
+ }
+ }
+ get isWidth() { return this._kind == Arg.Width; }
+ get isAlive() { return this.isTmp || this.isStack; }
+
+ get tmp()
+ {
+ if (this._kind != Arg.Tmp)
+ throw new Error("Called .tmp for non-tmp");
+ return this._tmp;
+ }
+
+ get value()
+ {
+ if (!this.isSomeImm)
+ throw new Error("Called .value for non-imm");
+ return this._value;
+ }
+
+ get base()
+ {
+ switch (this._kind) {
+ case Arg.Addr:
+ case Arg.Index:
+ return this._base;
+ default:
+ throw new Error("Called .base for non-address");
+ }
+ }
+
+ get hasOffset() { return this.isMemory; }
+
+ get offset()
+ {
+ switch (this._kind) {
+ case Arg.Addr:
+ case Arg.Index:
+ case Arg.Stack:
+ case Arg.CallArg:
+ return this._offset;
+ default:
+ throw new Error("Called .offset for non-address");
+ }
+ }
+
+ get stackSlot()
+ {
+ if (this._kind != Arg.Stack)
+ throw new Error("Called .stackSlot for non-address");
+ return this._slot;
+ }
+
+ get index()
+ {
+ if (this._kind != Arg.Index)
+ throw new Error("Called .index for non-Index");
+ return this._index;
+ }
+
+ get scale()
+ {
+ if (this._kind != Arg.Index)
+ throw new Error("Called .scale for non-Index");
+ return this._scale;
+ }
+
+ get logScale()
+ {
+ return Arg.logScale(this.scale);
+ }
+
+ get width()
+ {
+ if (this._kind != Arg.Width)
+ throw new Error("Called .width for non-Width");
+ return this._width;
+ }
+
+ get isGPTmp() { return this.isTmp && this.tmp.isGP; }
+ get isFPTmp() { return this.isTmp && this.tmp.isFP; }
+
+ get isGP()
+ {
+ switch (this._kind) {
+ case Arg.Imm:
+ case Arg.BigImm:
+ case Arg.BitImm:
+ case Arg.BitImm64:
+ case Arg.Addr:
+ case Arg.Index:
+ case Arg.Stack:
+ case Arg.CallArg:
+ case Arg.RelCond:
+ case Arg.ResCond:
+ case Arg.DoubleCond:
+ case Arg.Width:
+ return true;
+ case Arg.Tmp:
+ return this.isGPTmp;
+ case Arg.Invalid:
+ return false;
+ default:
+ throw new Error("Bad kind");
+ }
+ }
+
+ get isFP()
+ {
+ switch (this._kind) {
+ case Arg.Imm:
+ case Arg.BitImm:
+ case Arg.BitImm64:
+ case Arg.RelCond:
+ case Arg.ResCond:
+ case Arg.DoubleCond:
+ case Arg.Width:
+ case Arg.Invalid:
+ return false;
+ case Arg.Addr:
+ case Arg.Index:
+ case Arg.Stack:
+ case Arg.CallArg:
+ case Arg.BigImm:
+ return true;
+ case Arg.Tmp:
+ return this.isFPTmp;
+ default:
+ throw new Error("Bad kind");
+ }
+ }
+
+ get hasType()
+ {
+ switch (this._kind) {
+ case Arg.Imm:
+ case Arg.BitImm:
+ case Arg.BitImm64:
+ case Arg.Tmp:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ get type()
+ {
+ return this.isGP ? GP : FP;
+ }
+
+ isType(type)
+ {
+ switch (type) {
+ case Arg.GP:
+ return this.isGP;
+ case Arg.FP:
+ return this.isFP;
+ default:
+ throw new Error("Bad type");
+ }
+ }
+
+ isCompatibleType(other)
+ {
+ if (this.hasType)
+ return other.isType(this.type);
+ if (other.hasType)
+ return this.isType(other.type);
+ return true;
+ }
+
+ get isGPR() { return this.isTmp && this.tmp.isGPR; }
+ get gpr() { return this.tmp.gpr; }
+ get isFPR() { return this.isTmp && this.tmp.isFPR; }
+ get fpr() { return this.tmp.fpr; }
+ get isReg() { return this.isTmp && this.tmp.isReg; }
+ get reg() { return this.tmp.reg; }
+
+ static isValidImmForm(value)
+ {
+ return isRepresentableAsInt32(value);
+ }
+ static isValidBitImmForm(value)
+ {
+ return isRepresentableAsInt32(value);
+ }
+ static isValidBitImm64Form(value)
+ {
+ return isRepresentableAsInt32(value);
+ }
+
+ static isValidAddrForm(offset, width)
+ {
+ return true;
+ }
+
+ static isValidIndexForm(scale, offset, width)
+ {
+ if (!isValidScale(scale, width))
+ return false;
+ return true;
+ }
+
+ isValidForm(width)
+ {
+ switch (this._kind) {
+ case Arg.Invalid:
+ return false;
+ case Arg.Tmp:
+ return true;
+ case Arg.Imm:
+ return Arg.isValidImmForm(this.value);
+ case Arg.BigImm:
+ return true;
+ case Arg.BitImm:
+ return Arg.isValidBitImmForm(this.value);
+ case Arg.BitImm64:
+ return Arg.isValidBitImm64Form(this.value);
+ case Arg.Addr:
+ case Arg.Stack:
+ case Arg.CallArg:
+ return Arg.isValidAddrForm(this.offset, width);
+ case Arg.Index:
+ return Arg.isValidIndexForm(this.scale, this.offset, width);
+ case Arg.RelCond:
+ case Arg.ResCond:
+ case Arg.DoubleCond:
+ case Arg.Width:
+ return true;
+ default:
+ throw new Error("Bad kind");
+ }
+ }
+
+ forEachTmpFast(func)
+ {
+ switch (this._kind) {
+ case Arg.Tmp: {
+ let replacement;
+ if (replacement = func(this._tmp))
+ return Arg.createTmp(replacement);
+ break;
+ }
+ case Arg.Addr: {
+ let replacement;
+ if (replacement = func(this._base))
+ return Arg.createAddr(replacement, this._offset);
+ break;
+ }
+ case Arg.Index: {
+ let baseReplacement = func(this._base);
+ let indexReplacement = func(this._index);
+ if (baseReplacement || indexReplacement) {
+ return Arg.createIndex(
+ baseReplacement ? baseReplacement : this._base,
+ indexReplacement ? indexReplacement : this._index,
+ this._scale, this._offset);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ usesTmp(expectedTmp)
+ {
+ let usesTmp = false;
+ forEachTmpFast(tmp => {
+ usesTmp |= tmp == expectedTmp;
+ });
+ return usesTmp;
+ }
+
+ forEachTmp(role, type, width, func)
+ {
+ switch (this._kind) {
+ case Arg.Tmp: {
+ let replacement;
+ if (replacement = func(this._tmp, role, type, width))
+ return Arg.createTmp(replacement);
+ break;
+ }
+ case Arg.Addr: {
+ let replacement;
+ if (replacement = func(this._base, Arg.Use, GP, role == Arg.UseAddr ? width : Ptr))
+ return Arg.createAddr(replacement, this._offset);
+ break;
+ }
+ case Arg.Index: {
+ let baseReplacement = func(this._base, Arg.Use, GP, role == Arg.UseAddr ? width : Ptr);
+ let indexReplacement = func(this._index, Arg.Use, GP, role == Arg.UseAddr ? width : Ptr);
+ if (baseReplacement || indexReplacement) {
+ return Arg.createIndex(
+ baseReplacement ? baseReplacement : this._base,
+ indexReplacement ? indexReplacement : this._index,
+ this._scale, this._offset);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ is(thing) { return !!thing.extract(this); }
+ as(thing) { return thing.extract(this); }
+
+ // This lets you say things like:
+ // arg.forEach(Tmp | Reg | Arg | StackSlot, ...)
+ //
+ // It's used for abstract liveness analysis.
+ forEachFast(thing, func)
+ {
+ return thing.forEachFast(this, func);
+ }
+ forEach(thing, role, type, width, func)
+ {
+ return thing.forEach(this, role, type, width, func);
+ }
+
+ static extract(arg) { return arg; }
+ static forEachFast(arg, func) { return func(arg); }
+ static forEach(arg, role, type, width, func) { return func(arg, role, type, width); }
+
+ get condition()
+ {
+ switch (this._kind) {
+ case Arg.RelCond:
+ case Arg.ResCond:
+ case Arg.DoubleCond:
+ return this._condition;
+ default:
+ throw new Error("Called .condition for non-condition");
+ }
+ }
+
+ get isInvertible()
+ {
+ switch (this._kind) {
+ case Arg.RelCond:
+ case Arg.DoubleCold:
+ return true;
+ case Arg.ResCond:
+ switch (this._condition) {
+ case Zero:
+ case NonZero:
+ case Signed:
+ case PositiveOrZero:
+ return true;
+ default:
+ return false;
+ }
+ default:
+ return false;
+ }
+ }
+
+ toString()
+ {
+ switch (this._kind) {
+ case Arg.Invalid:
+ return "<invalid>";
+ case Arg.Tmp:
+ return this._tmp.toString();
+ case Arg.Imm:
+ case Arg.BitImm:
+ return "$" + this._value;
+ case Arg.BigImm:
+ case Arg.BitImm64:
+ return "$0x" + this._value.toString(16);
+ case Arg.Addr:
+ return "" + (this._offset ? this._offset : "") + "(" + this._base + ")";
+ case Arg.Index:
+ return "" + (this._offset ? this._offset : "") + "(" + this._base +
+ "," + this._index + (this._scale == 1 ? "" : "," + this._scale) + ")";
+ case Arg.Stack:
+ return "" + (this._offset ? this._offset : "") + "(" + this._slot + ")";
+ case Arg.CallArg:
+ return "" + (this._offset ? this._offset : "") + "(callArg)";
+ case Arg.RelCond:
+ case Arg.ResCond:
+ case Arg.DoubleCond:
+ case Arg.Width:
+ return symbolName(this._condition);
+ default:
+ throw new Error("Bad kind");
+ }
+ }
+}
+
+// Arg kinds
+Arg.Invalid = Symbol("Invalid");
+Arg.Tmp = Symbol("Tmp");
+Arg.Imm = Symbol("Imm");
+Arg.BigImm = Symbol("BigImm");
+Arg.BitImm = Symbol("BitImm");
+Arg.BitImm64 = Symbol("BitImm64");
+Arg.Addr = Symbol("Addr");
+Arg.Stack = Symbol("Stack");
+Arg.CallArg = Symbol("CallArg");
+Arg.Index = Symbol("Index");
+Arg.RelCond = Symbol("RelCond");
+Arg.ResCond = Symbol("ResCond");
+Arg.DoubleCond = Symbol("DoubleCond");
+Arg.Width = Symbol("Width");
+
+// Arg roles
+Arg.Use = Symbol("Use");
+Arg.ColdUse = Symbol("ColdUse");
+Arg.LateUse = Symbol("LateUse");
+Arg.LateColdUse = Symbol("LateColdUse");
+Arg.Def = Symbol("Def");
+Arg.ZDef = Symbol("ZDef");
+Arg.UseDef = Symbol("UseDef");
+Arg.UseZDef = Symbol("UseZDef");
+Arg.EarlyDef = Symbol("EarlyDef");
+Arg.Scratch = Symbol("Scratch");
+Arg.UseAddr = Symbol("UseAddr");
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirbasic_blockjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/basic_block.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/basic_block.js (rev 0)
+++ trunk/PerformanceTests/JSAir/basic_block.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,133 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class BasicBlock {
+ constructor(index, frequency)
+ {
+ this._index = index;
+ this._frequency = frequency;
+ this._insts = [];
+ this._successors = [];
+ this._predecessors = [];
+ }
+
+ get index() { return this._index; }
+ get size() { return this._insts.length; }
+
+ [Symbol.iterator]()
+ {
+ return this._insts[Symbol.iterator]();
+ }
+
+ at(index)
+ {
+ if (index >= this._insts.length)
+ throw new Error("Out of bounds access");
+ return this._insts[index];
+ }
+
+ get(index)
+ {
+ if (index >= this._insts.length)
+ return null;
+ return this._insts[index];
+ }
+
+ get last()
+ {
+ return this._insts[this._insts.length - 1];
+ }
+
+ get insts() { return this._insts; }
+
+ append(inst) { this._insts.push(inst); }
+
+ get numSuccessors() { return this._successors.length; }
+ successor(index) { return this._successors[index]; }
+ get successors() { return this._successors; }
+
+ successorBlock(index) { return this._successors[index].block; }
+ get successorBlocks()
+ {
+ return new Proxy(this._successors, {
+ get(target, property) {
+ if ((property | 0) == property)
+ return target[property].block;
+ return target[property];
+ },
+
+ set(target, property, value) {
+ if ((property | 0) == property) {
+ var oldValue = target[property];
+ target[property] = new FrequentedBlock(
+ value, oldValue ? oldValue.frequency : Normal);
+ return;
+ }
+
+ target[property] = value;
+ }
+ });
+ }
+
+ get numPredecessors() { return this._predecessors.length; }
+ predecessor(index) { return this._predecessors[index]; }
+ get predecessors() { return this._predecessors; }
+
+ get frequency() { return this._frequency; }
+
+ toString()
+ {
+ return "#" + this._index;
+ }
+
+ get headerString()
+ {
+ let result = "";
+ result += "BB" + this + ": ; frequency = " + this._frequency + "\n";
+ if (this._predecessors.length)
+ result += " Predecessors: " + this._predecessors.join(", ") + "\n";
+ return result;
+ }
+
+ get footerString()
+ {
+ let result = "";
+ if (this._successors.length)
+ result += " Successors: " + this._successors.join(", ") + "\n";
+ return result;
+ }
+
+ toStringDeep()
+ {
+ let result = "";
+ result += this.headerString;
+ for (let inst of this)
+ result += " " + inst + "\n";
+ result += this.footerString;
+ return result;
+ }
+}
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirbenchmarkjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/benchmark.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/benchmark.js (rev 0)
+++ trunk/PerformanceTests/JSAir/benchmark.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,61 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+function benchmark()
+{
+ const verbose = 0;
+ const numIterations = 200;
+
+ let before = currentTime();
+
+ var codeGenerators = [
+ createPayloadGbemuExecuteIteration,
+ createPayloadImagingGaussianBlurGaussianBlur,
+ createPayloadTypescriptScanIdentifier,
+ createPayloadJSAirACLj8C
+ ];
+
+ for (let iteration = 0; iteration < numIterations; ++iteration) {
+ for (let generateCode of codeGenerators) {
+ let code = generateCode();
+
+ if (verbose) {
+ print("Before allocateStack:");
+ print(code);
+ }
+
+ allocateStack(code);
+
+ if (verbose) {
+ print("After allocateStack:");
+ print(code);
+ }
+ }
+ }
+
+ let after = currentTime();
+ return after - before;
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAircodejs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/code.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/code.js (rev 0)
+++ trunk/PerformanceTests/JSAir/code.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,99 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Code {
+ constructor()
+ {
+ this._blocks = [];
+ this._stackSlots = [];
+ this._gpTmps = [];
+ this._fpTmps = [];
+ this._callArgAreaSize = 0;
+ this._frameSize = 0;
+ }
+
+ addBlock(frequency)
+ {
+ if (frequency == null)
+ frequency = 1;
+ let result = addIndexed(this._blocks, BasicBlock, frequency);
+ return result;
+ }
+
+ addStackSlot(byteSize, kind)
+ {
+ let result = addIndexed(this._stackSlots, StackSlot, byteSize, kind);
+ return result;
+ }
+
+ newTmp(type)
+ {
+ let result = addIndexed(this["_" + symbolName(type).toLowerCase() + "Tmps"], Tmp, type);
+ return result;
+ }
+
+ get size() { return this._blocks.length; }
+ at(index) { return this._blocks[index]; }
+
+ [Symbol.iterator]()
+ {
+ return this._blocks[Symbol.iterator]();
+ }
+
+ get blocks() { return this._blocks; }
+ get stackSlots() { return this._stackSlots; }
+
+ tmps(type) { return this["_" + symbolName(type).toLowerCase() + "Tmps"]; }
+
+ get callArgAreaSize() { return this._callArgAreaSize; }
+
+ requestCallArgAreaSize(size)
+ {
+ this._callArgAreaSize = Math.max(this._callArgAreaSize, roundUpToMultipleOf(stackAlignmentBytes, size));
+ }
+
+ get frameSize() { return this._frameSize; }
+
+ setFrameSize(frameSize) { this._frameSize = frameSize; }
+
+ toString()
+ {
+ let result = "";
+ for (let block of this) {
+ result += block.toStringDeep();
+ }
+ if (this.stackSlots.length) {
+ result += "Stack slots:\n";
+ for (let slot of this.stackSlots)
+ result += " " + slot + "\n";
+ }
+ if (this._frameSize)
+ result += "Frame size: " + this._frameSize + "\n";
+ if (this._callArgAreaSize)
+ result += "Call arg area size: " + this._callArgAreaSize + "\n";
+ return result;
+ }
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAircustomjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/custom.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/custom.js (rev 0)
+++ trunk/PerformanceTests/JSAir/custom.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,104 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+const ShuffleCustom = {
+ forEachArg(inst, func)
+ {
+ var limit = inst.args.length / 3 * 3;
+ for (let i = 0; i < limit; i += 3) {
+ let src = inst.args[i + 0];
+ let dst = inst.args[i + 1];
+ let widthArg = inst.args[i + 2];
+ let width = widthArg.width;
+ let type = src.isGP && dst.isGP ? GP : FP;
+ inst.visitArg(i + 0, func, Arg.Use, type, width);
+ inst.visitArg(i + 1, func, Arg.Def, type, width);
+ inst.visitArg(i + 2, func, Arg.Use, GP, 8);
+ }
+ },
+
+ hasNonArgNonControlEffects(inst)
+ {
+ return false;
+ }
+};
+
+const PatchCustom = {
+ forEachArg(inst, func)
+ {
+ for (let i = 0; i < inst.args.length; ++i) {
+ inst.visitArg(
+ i, func, inst.patchArgData[i].role, inst.patchArgData[i].type,
+ inst.patchArgData[i].width);
+ }
+ },
+
+ hasNonArgNonControlEffects(inst)
+ {
+ return inst.patchHasNonArgEffects;
+ }
+};
+
+const CCallCustom = {
+ forEachArg(inst, func)
+ {
+ let index = 0;
+ inst.visitArg(index++, func, Arg.Use, GP, Ptr); // callee
+
+ if (inst.cCallType != Void) {
+ inst.visitArg(
+ index++, func, Arg.Def, Arg.typeForB3Type(inst.cCallType),
+ Arg.widthForB3Type(inst.cCallType));
+ }
+
+ for (let type of inst.cCallArgTypes) {
+ inst.visitArg(
+ index++, func, Arg.Use, Arg.typeForB3Type(type), Arg.widthForB3Type(type));
+ }
+ },
+
+ hasNonArgNonControlEffects(inst)
+ {
+ return true;
+ }
+};
+
+const ColdCCallCustom = {
+ forEachArg(inst, func)
+ {
+ CCallCustom.forEachArg(
+ inst,
+ (arg, role, type, width) => {
+ return func(arg, Arg.cooled(role), type, width);
+ });
+ },
+
+ hasNonArgNonControlEffects(inst)
+ {
+ return true;
+ }
+};
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirfrequented_blockjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/frequented_block.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/frequented_block.js (rev 0)
+++ trunk/PerformanceTests/JSAir/frequented_block.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,38 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class FrequentedBlock {
+ constructor(block, frequency)
+ {
+ this.block = block;
+ this.frequency = frequency;
+ }
+
+ toString()
+ {
+ return (this.frequency == Normal ? "" : "Rare:") + this.block;
+ }
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirinsertion_setjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/insertion_set.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/insertion_set.js (rev 0)
+++ trunk/PerformanceTests/JSAir/insertion_set.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,89 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Insertion {
+ constructor(index, element)
+ {
+ this._index = index;
+ this._element = element;
+ }
+
+ get index() { return this._index; }
+ get element() { return this._element; }
+
+ lessThan(other)
+ {
+ return this._index < other._index;
+ }
+}
+
+class InsertionSet {
+ constructor()
+ {
+ this._insertions = []
+ }
+
+ appendInsertion(insertion)
+ {
+ this._insertions.push(insertion);
+ }
+
+ append(index, element)
+ {
+ this.appendInsertion(new Insertion(index, element));
+ }
+
+ execute(target)
+ {
+ // We bubble-sort because that's what the C++ code, and for the same reason as we do it:
+ // the stdlib doesn't have a stable sort and mergesort is slower in the common case of the
+ // array usually being sorted. This array is usually sorted.
+ bubbleSort(this._insertions, (a, b) => (a.lessThan(b)));
+
+ let numInsertions = this._insertions.length;
+ if (!numInsertions)
+ return 0;
+ let originalTargetSize = target.length;
+ target.length += numInsertions;
+ let lastIndex = target.length;
+ for (let indexInInsertions = numInsertions; indexInInsertions--;) {
+ let insertion = this._insertions[indexInInsertions];
+ if (indexInInsertions && insertion.index < this._insertions[indexInInsertions - 1].index)
+ throw new Error("Insertions out of order");
+ if (insertion.index > originalTargetSize)
+ throw new Error("Out-of-bounds insertion");
+ let firstIndex = insertion.index + indexInInsertions;
+ let indexOffset = indexInInsertions + 1;
+ for (let i = lastIndex; --i > firstIndex;)
+ target[i] = target[i - indexOffset];
+ target[firstIndex] = insertion.element;
+ lastIndex = firstIndex;
+ }
+ this._insertions = [];
+ return numInsertions;
+ }
+}
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirinstjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/inst.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/inst.js (rev 0)
+++ trunk/PerformanceTests/JSAir/inst.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,133 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Inst {
+ constructor(opcode, args)
+ {
+ this._opcode = opcode;
+ this._args = args == null ? [] : args;
+ }
+
+ append(...args)
+ {
+ this._args.push(...args);
+ }
+
+ clear()
+ {
+ this._opcode = Nop;
+ this._args = [];
+ }
+
+ get opcode() { return this._opcode; }
+ get args() { return this._args; }
+
+ visitArg(index, func, ...args)
+ {
+ let replacement = func(this._args[index], ...args);
+ if (replacement)
+ this._args[index] = replacement;
+ }
+
+ forEachTmpFast(func)
+ {
+ for (let i = 0; i < this._args.length; ++i) {
+ let replacement;
+ if (replacement = this._args[i].forEachTmpFast(func))
+ this._args[i] = replacement;
+ }
+ }
+
+ forEachArg(func)
+ {
+ Inst_forEachArg(this, func);
+ }
+
+ forEachTmp(func)
+ {
+ this.forEachArg((arg, role, type, width) => {
+ return arg.forEachTmp(role, type, width, func);
+ });
+ }
+
+ forEach(thing, func)
+ {
+ this.forEachArg((arg, role, type, width) => {
+ return arg.forEach(thing, role, type, width, func);
+ });
+ }
+
+ static forEachDef(thing, prevInst, nextInst, func)
+ {
+ if (prevInst) {
+ prevInst.forEach(
+ thing,
+ (value, role, type, width) => {
+ if (Arg.isLateDef(role))
+ return func(value, role, type, width);
+ });
+ }
+
+ if (nextInst) {
+ nextInst.forEach(
+ thing,
+ (value, role, type, width) => {
+ if (Arg.isEarlyDef(role))
+ return func(value, role, type, width);
+ });
+ }
+ }
+
+ static forEachDefWithExtraClobberedRegs(thing, prevInst, nextInst, func)
+ {
+ forEachDef(thing, prevInst, nextInst, func);
+
+ let regDefRole;
+
+ let reportReg = reg => {
+ let type = reg.isGPR ? GP : FP;
+ func(thing.fromReg(reg), regDefRole, type, Arg.conservativeWidth(type));
+ };
+
+ if (prevInst && prevInst.opcode == Patch) {
+ regDefRole = Arg.Def;
+ prevInst.extraClobberedRegs.forEach(reportReg);
+ }
+
+ if (nextInst && nextInst.opcode == Patch) {
+ regDefRole = Arg.EarlyDef;
+ nextInst.extraEarlyClobberedRegs.forEach(reportReg);
+ }
+ }
+
+ get hasNonArgEffects() { return Inst_hasNonArgEffects(this); }
+
+ toString()
+ {
+ return "" + symbolName(this._opcode) + " " + this._args.join(", ");
+ }
+}
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirlivenessjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/liveness.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/liveness.js (rev 0)
+++ trunk/PerformanceTests/JSAir/liveness.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,152 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Liveness {
+ constructor(thing, code)
+ {
+ this._thing = thing;
+ this._code = code;
+
+ this._liveAtHead = new Map();
+ this._liveAtTail = new Map();
+
+ for (let block of code) {
+ this._liveAtHead.set(block, new Set());
+
+ let liveAtTail = new Set();
+ this._liveAtTail.set(block, liveAtTail);
+
+ block.last.forEach(
+ thing,
+ (value, role, type, width) => {
+ if (Arg.isLateUse(role))
+ liveAtTail.add(value);
+ });
+ }
+
+ let dirtyBlocks = new Set(code);
+
+ let changed;
+ do {
+ changed = false;
+
+ for (let blockIndex = code.size; blockIndex--;) {
+ let block = code.at(blockIndex);
+ if (!block)
+ continue;
+
+ if (!dirtyBlocks.delete(block))
+ continue;
+
+ let localCalc = this.localCalc(block);
+ for (let instIndex = block.size; instIndex--;)
+ localCalc.execute(instIndex);
+
+ // Handle the early def's of the first instruction.
+ block.at(0).forEach(
+ thing,
+ (value, role, type, width) => {
+ if (Arg.isEarlyDef(role))
+ localCalc.liveSet.remove(value);
+ });
+
+ let liveAtHead = this._liveAtHead.get(block);
+
+ if (!mergeIntoSet(liveAtHead, localCalc.liveSet))
+ continue;
+
+ for (let predecessor of block.predecessors) {
+ if (mergeIntoSet(this._liveAtTail.get(predecessor), liveAtHead)) {
+ dirtyBlocks.add(predecessor);
+ changed = true;
+ }
+ }
+ }
+ } while (changed);
+ }
+
+ get thing() { return this._thing; }
+ get code() { return this._code; }
+ get liveAtHead() { return this._liveAtHead; }
+ get liveAtTail() { return this._liveAtTail; }
+
+ localCalc(block)
+ {
+ let liveness = this;
+ class LocalCalc {
+ constructor()
+ {
+ this._liveSet = new Set(liveness.liveAtTail.get(block));
+ }
+
+ get liveSet() { return this._liveSet; }
+
+ execute(instIndex)
+ {
+ let inst = block.at(instIndex);
+
+ // First handle the early defs of the next instruction.
+ if (instIndex + 1 < block.size) {
+ block.at(instIndex + 1).forEach(
+ liveness.thing,
+ (value, role, type, width) => {
+ if (Arg.isEarlyDef(role))
+ this._liveSet.delete(value);
+ });
+ }
+
+ // Then handle defs.
+ inst.forEach(
+ liveness.thing,
+ (value, role, type, width) => {
+ if (Arg.isLateDef(role))
+ this._liveSet.delete(value);
+ });
+
+ // Then handle uses.
+ inst.forEach(
+ liveness.thing,
+ (value, role, type, width) => {
+ if (Arg.isEarlyUse(role))
+ this._liveSet.add(value);
+ });
+
+ // Finally handle the late uses of the previous instruction.
+ if (instIndex - 1 >= 0) {
+ block.at(instIndex - 1).forEach(
+ liveness.thing,
+ (value, role, type, width) => {
+ if (Arg.isLateUse(role))
+ this._liveSet.add(value);
+ });
+ }
+ }
+ }
+
+ return new LocalCalc();
+ }
+}
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAiropcodejs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/opcode.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/opcode.js (rev 0)
+++ trunk/PerformanceTests/JSAir/opcode.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,1380 @@
</span><ins>+"use strict";
+// Generated by opcode_generator.rb from JavaScriptCore/b3/air/AirOpcode.opcodes -- do not edit!
+const Nop = Symbol("Nop");
+const Add32 = Symbol("Add32");
+const Add8 = Symbol("Add8");
+const Add16 = Symbol("Add16");
+const Add64 = Symbol("Add64");
+const AddDouble = Symbol("AddDouble");
+const AddFloat = Symbol("AddFloat");
+const Sub32 = Symbol("Sub32");
+const Sub64 = Symbol("Sub64");
+const SubDouble = Symbol("SubDouble");
+const SubFloat = Symbol("SubFloat");
+const Neg32 = Symbol("Neg32");
+const Neg64 = Symbol("Neg64");
+const NegateDouble = Symbol("NegateDouble");
+const Mul32 = Symbol("Mul32");
+const Mul64 = Symbol("Mul64");
+const MultiplyAdd32 = Symbol("MultiplyAdd32");
+const MultiplyAdd64 = Symbol("MultiplyAdd64");
+const MultiplySub32 = Symbol("MultiplySub32");
+const MultiplySub64 = Symbol("MultiplySub64");
+const MultiplyNeg32 = Symbol("MultiplyNeg32");
+const MultiplyNeg64 = Symbol("MultiplyNeg64");
+const Div32 = Symbol("Div32");
+const Div64 = Symbol("Div64");
+const MulDouble = Symbol("MulDouble");
+const MulFloat = Symbol("MulFloat");
+const DivDouble = Symbol("DivDouble");
+const DivFloat = Symbol("DivFloat");
+const X86ConvertToDoubleWord32 = Symbol("X86ConvertToDoubleWord32");
+const X86ConvertToQuadWord64 = Symbol("X86ConvertToQuadWord64");
+const X86Div32 = Symbol("X86Div32");
+const X86Div64 = Symbol("X86Div64");
+const Lea = Symbol("Lea");
+const And32 = Symbol("And32");
+const And64 = Symbol("And64");
+const AndDouble = Symbol("AndDouble");
+const AndFloat = Symbol("AndFloat");
+const XorDouble = Symbol("XorDouble");
+const XorFloat = Symbol("XorFloat");
+const Lshift32 = Symbol("Lshift32");
+const Lshift64 = Symbol("Lshift64");
+const Rshift32 = Symbol("Rshift32");
+const Rshift64 = Symbol("Rshift64");
+const Urshift32 = Symbol("Urshift32");
+const Urshift64 = Symbol("Urshift64");
+const Or32 = Symbol("Or32");
+const Or64 = Symbol("Or64");
+const Xor32 = Symbol("Xor32");
+const Xor64 = Symbol("Xor64");
+const Not32 = Symbol("Not32");
+const Not64 = Symbol("Not64");
+const AbsDouble = Symbol("AbsDouble");
+const AbsFloat = Symbol("AbsFloat");
+const CeilDouble = Symbol("CeilDouble");
+const CeilFloat = Symbol("CeilFloat");
+const FloorDouble = Symbol("FloorDouble");
+const FloorFloat = Symbol("FloorFloat");
+const SqrtDouble = Symbol("SqrtDouble");
+const SqrtFloat = Symbol("SqrtFloat");
+const ConvertInt32ToDouble = Symbol("ConvertInt32ToDouble");
+const ConvertInt64ToDouble = Symbol("ConvertInt64ToDouble");
+const ConvertInt32ToFloat = Symbol("ConvertInt32ToFloat");
+const ConvertInt64ToFloat = Symbol("ConvertInt64ToFloat");
+const CountLeadingZeros32 = Symbol("CountLeadingZeros32");
+const CountLeadingZeros64 = Symbol("CountLeadingZeros64");
+const ConvertDoubleToFloat = Symbol("ConvertDoubleToFloat");
+const ConvertFloatToDouble = Symbol("ConvertFloatToDouble");
+const Move = Symbol("Move");
+const Swap32 = Symbol("Swap32");
+const Swap64 = Symbol("Swap64");
+const Move32 = Symbol("Move32");
+const StoreZero32 = Symbol("StoreZero32");
+const SignExtend32ToPtr = Symbol("SignExtend32ToPtr");
+const ZeroExtend8To32 = Symbol("ZeroExtend8To32");
+const SignExtend8To32 = Symbol("SignExtend8To32");
+const ZeroExtend16To32 = Symbol("ZeroExtend16To32");
+const SignExtend16To32 = Symbol("SignExtend16To32");
+const MoveFloat = Symbol("MoveFloat");
+const MoveDouble = Symbol("MoveDouble");
+const MoveZeroToDouble = Symbol("MoveZeroToDouble");
+const Move64ToDouble = Symbol("Move64ToDouble");
+const Move32ToFloat = Symbol("Move32ToFloat");
+const MoveDoubleTo64 = Symbol("MoveDoubleTo64");
+const MoveFloatTo32 = Symbol("MoveFloatTo32");
+const Load8 = Symbol("Load8");
+const Store8 = Symbol("Store8");
+const Load8SignedExtendTo32 = Symbol("Load8SignedExtendTo32");
+const Load16 = Symbol("Load16");
+const Load16SignedExtendTo32 = Symbol("Load16SignedExtendTo32");
+const Store16 = Symbol("Store16");
+const Compare32 = Symbol("Compare32");
+const Compare64 = Symbol("Compare64");
+const Test32 = Symbol("Test32");
+const Test64 = Symbol("Test64");
+const CompareDouble = Symbol("CompareDouble");
+const CompareFloat = Symbol("CompareFloat");
+const Branch8 = Symbol("Branch8");
+const Branch32 = Symbol("Branch32");
+const Branch64 = Symbol("Branch64");
+const BranchTest8 = Symbol("BranchTest8");
+const BranchTest32 = Symbol("BranchTest32");
+const BranchTest64 = Symbol("BranchTest64");
+const BranchDouble = Symbol("BranchDouble");
+const BranchFloat = Symbol("BranchFloat");
+const BranchAdd32 = Symbol("BranchAdd32");
+const BranchAdd64 = Symbol("BranchAdd64");
+const BranchMul32 = Symbol("BranchMul32");
+const BranchMul64 = Symbol("BranchMul64");
+const BranchSub32 = Symbol("BranchSub32");
+const BranchSub64 = Symbol("BranchSub64");
+const BranchNeg32 = Symbol("BranchNeg32");
+const BranchNeg64 = Symbol("BranchNeg64");
+const MoveConditionally32 = Symbol("MoveConditionally32");
+const MoveConditionally64 = Symbol("MoveConditionally64");
+const MoveConditionallyTest32 = Symbol("MoveConditionallyTest32");
+const MoveConditionallyTest64 = Symbol("MoveConditionallyTest64");
+const MoveConditionallyDouble = Symbol("MoveConditionallyDouble");
+const MoveConditionallyFloat = Symbol("MoveConditionallyFloat");
+const MoveDoubleConditionally32 = Symbol("MoveDoubleConditionally32");
+const MoveDoubleConditionally64 = Symbol("MoveDoubleConditionally64");
+const MoveDoubleConditionallyTest32 = Symbol("MoveDoubleConditionallyTest32");
+const MoveDoubleConditionallyTest64 = Symbol("MoveDoubleConditionallyTest64");
+const MoveDoubleConditionallyDouble = Symbol("MoveDoubleConditionallyDouble");
+const MoveDoubleConditionallyFloat = Symbol("MoveDoubleConditionallyFloat");
+const Jump = Symbol("Jump");
+const Ret32 = Symbol("Ret32");
+const Ret64 = Symbol("Ret64");
+const RetFloat = Symbol("RetFloat");
+const RetDouble = Symbol("RetDouble");
+const Oops = Symbol("Oops");
+const Shuffle = Symbol("Shuffle");
+const Patch = Symbol("Patch");
+const CCall = Symbol("CCall");
+const ColdCCall = Symbol("ColdCCall");
+function Inst_forEachArg(inst, func)
+{
+ let replacement;
+ switch (inst.opcode) {
+ case Nop:
+ break;
+ break;
+ case Add32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Add8:
+ inst.visitArg(0, func, Arg.Use, GP, 8);
+ inst.visitArg(1, func, Arg.UseDef, GP, 8);
+ break;
+ break;
+ case Add16:
+ inst.visitArg(0, func, Arg.Use, GP, 16);
+ inst.visitArg(1, func, Arg.UseDef, GP, 16);
+ break;
+ break;
+ case Add64:
+ switch (inst.args.length) {
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Def, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case AddDouble:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Def, FP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.UseDef, FP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case AddFloat:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.UseDef, FP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Sub32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ break;
+ case Sub64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ break;
+ case SubDouble:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Def, FP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.UseDef, FP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case SubFloat:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.UseDef, FP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Neg32:
+ inst.visitArg(0, func, Arg.UseZDef, GP, 32);
+ break;
+ break;
+ case Neg64:
+ inst.visitArg(0, func, Arg.UseDef, GP, 64);
+ break;
+ break;
+ case NegateDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case Mul32:
+ switch (inst.args.length) {
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Mul64:
+ switch (inst.args.length) {
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Def, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MultiplyAdd32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case MultiplyAdd64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Def, GP, 64);
+ break;
+ break;
+ case MultiplySub32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case MultiplySub64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Def, GP, 64);
+ break;
+ break;
+ case MultiplyNeg32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case MultiplyNeg64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.ZDef, GP, 64);
+ break;
+ break;
+ case Div32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Div64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Def, GP, 64);
+ break;
+ break;
+ case MulDouble:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Def, FP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.UseDef, FP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MulFloat:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.UseDef, FP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case DivDouble:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.UseDef, FP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case DivFloat:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.UseDef, FP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case X86ConvertToDoubleWord32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case X86ConvertToQuadWord64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Def, GP, 64);
+ break;
+ break;
+ case X86Div32:
+ inst.visitArg(0, func, Arg.UseZDef, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ break;
+ break;
+ case X86Div64:
+ inst.visitArg(0, func, Arg.UseZDef, GP, 64);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ break;
+ break;
+ case Lea:
+ inst.visitArg(0, func, Arg.UseAddr, GP, Ptr);
+ inst.visitArg(1, func, Arg.Def, GP, Ptr);
+ break;
+ break;
+ case And32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case And64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Def, GP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case AndDouble:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Def, FP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.UseDef, FP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case AndFloat:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.UseDef, FP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case XorDouble:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Def, FP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.UseDef, FP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case XorFloat:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Def, FP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.UseDef, FP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Lshift32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Lshift64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.ZDef, GP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Rshift32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Rshift64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.ZDef, GP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Urshift32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Urshift64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.ZDef, GP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Or32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Or64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Def, GP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Xor32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.ZDef, GP, 32);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Xor64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Def, GP, 64);
+ break;
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Not32:
+ switch (inst.args.length) {
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ case 1:
+ inst.visitArg(0, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case Not64:
+ switch (inst.args.length) {
+ case 2:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Def, GP, 64);
+ break;
+ case 1:
+ inst.visitArg(0, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case AbsDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case AbsFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case CeilDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case CeilFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case FloorDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case FloorFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case SqrtDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case SqrtFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case ConvertInt32ToDouble:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case ConvertInt64ToDouble:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case ConvertInt32ToFloat:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case ConvertInt64ToFloat:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case CountLeadingZeros32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case CountLeadingZeros64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Def, GP, 64);
+ break;
+ break;
+ case ConvertDoubleToFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case ConvertFloatToDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case Move:
+ inst.visitArg(0, func, Arg.Use, GP, Ptr);
+ inst.visitArg(1, func, Arg.Def, GP, Ptr);
+ break;
+ break;
+ case Swap32:
+ inst.visitArg(0, func, Arg.UseDef, GP, 32);
+ inst.visitArg(1, func, Arg.UseDef, GP, 32);
+ break;
+ break;
+ case Swap64:
+ inst.visitArg(0, func, Arg.UseDef, GP, 64);
+ inst.visitArg(1, func, Arg.UseDef, GP, 64);
+ break;
+ break;
+ case Move32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case StoreZero32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ break;
+ break;
+ case SignExtend32ToPtr:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Def, GP, Ptr);
+ break;
+ break;
+ case ZeroExtend8To32:
+ inst.visitArg(0, func, Arg.Use, GP, 8);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case SignExtend8To32:
+ inst.visitArg(0, func, Arg.Use, GP, 8);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case ZeroExtend16To32:
+ inst.visitArg(0, func, Arg.Use, GP, 16);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case SignExtend16To32:
+ inst.visitArg(0, func, Arg.Use, GP, 16);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case MoveFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case MoveDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case MoveZeroToDouble:
+ inst.visitArg(0, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case Move64ToDouble:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ inst.visitArg(1, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case Move32ToFloat:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Def, FP, 32);
+ break;
+ break;
+ case MoveDoubleTo64:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ inst.visitArg(1, func, Arg.Def, GP, 64);
+ break;
+ break;
+ case MoveFloatTo32:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ inst.visitArg(1, func, Arg.Def, GP, 32);
+ break;
+ break;
+ case Load8:
+ inst.visitArg(0, func, Arg.Use, GP, 8);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Store8:
+ inst.visitArg(0, func, Arg.Use, GP, 8);
+ inst.visitArg(1, func, Arg.Def, GP, 8);
+ break;
+ break;
+ case Load8SignedExtendTo32:
+ inst.visitArg(0, func, Arg.Use, GP, 8);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Load16:
+ inst.visitArg(0, func, Arg.Use, GP, 16);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Load16SignedExtendTo32:
+ inst.visitArg(0, func, Arg.Use, GP, 16);
+ inst.visitArg(1, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Store16:
+ inst.visitArg(0, func, Arg.Use, GP, 16);
+ inst.visitArg(1, func, Arg.Def, GP, 16);
+ break;
+ break;
+ case Compare32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Compare64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Test32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Test64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case CompareDouble:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Use, FP, 64);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case CompareFloat:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Use, FP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ break;
+ case Branch8:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 8);
+ inst.visitArg(2, func, Arg.Use, GP, 8);
+ break;
+ break;
+ case Branch32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ break;
+ break;
+ case Branch64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ break;
+ break;
+ case BranchTest8:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 8);
+ inst.visitArg(2, func, Arg.Use, GP, 8);
+ break;
+ break;
+ case BranchTest32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ break;
+ break;
+ case BranchTest64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ break;
+ break;
+ case BranchDouble:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Use, FP, 64);
+ break;
+ break;
+ case BranchFloat:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Use, FP, 32);
+ break;
+ break;
+ case BranchAdd32:
+ switch (inst.args.length) {
+ case 4:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.UseZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case BranchAdd64:
+ switch (inst.args.length) {
+ case 4:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.ZDef, GP, 64);
+ break;
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.UseDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case BranchMul32:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.UseZDef, GP, 32);
+ break;
+ case 4:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.ZDef, GP, 32);
+ break;
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Scratch, GP, 32);
+ inst.visitArg(4, func, Arg.Scratch, GP, 32);
+ inst.visitArg(5, func, Arg.ZDef, GP, 32);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case BranchMul64:
+ switch (inst.args.length) {
+ case 3:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.UseZDef, GP, 64);
+ break;
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Scratch, GP, 64);
+ inst.visitArg(4, func, Arg.Scratch, GP, 64);
+ inst.visitArg(5, func, Arg.ZDef, GP, 64);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case BranchSub32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.UseZDef, GP, 32);
+ break;
+ break;
+ case BranchSub64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.UseDef, GP, 64);
+ break;
+ break;
+ case BranchNeg32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 32);
+ break;
+ break;
+ case BranchNeg64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.UseZDef, GP, 64);
+ break;
+ break;
+ case MoveConditionally32:
+ switch (inst.args.length) {
+ case 5:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
+ break;
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.Use, GP, Ptr);
+ inst.visitArg(5, func, Arg.Def, GP, Ptr);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MoveConditionally64:
+ switch (inst.args.length) {
+ case 5:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
+ break;
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.Use, GP, Ptr);
+ inst.visitArg(5, func, Arg.Def, GP, Ptr);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MoveConditionallyTest32:
+ switch (inst.args.length) {
+ case 5:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
+ break;
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.Use, GP, Ptr);
+ inst.visitArg(5, func, Arg.Def, GP, Ptr);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MoveConditionallyTest64:
+ switch (inst.args.length) {
+ case 5:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
+ break;
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.Use, GP, Ptr);
+ inst.visitArg(5, func, Arg.Def, GP, Ptr);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MoveConditionallyDouble:
+ switch (inst.args.length) {
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Use, FP, 64);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.Use, GP, Ptr);
+ inst.visitArg(5, func, Arg.Def, GP, Ptr);
+ break;
+ case 5:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Use, FP, 64);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MoveConditionallyFloat:
+ switch (inst.args.length) {
+ case 6:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Use, FP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.Use, GP, Ptr);
+ inst.visitArg(5, func, Arg.Def, GP, Ptr);
+ break;
+ case 5:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Use, FP, 32);
+ inst.visitArg(3, func, Arg.Use, GP, Ptr);
+ inst.visitArg(4, func, Arg.UseDef, GP, Ptr);
+ break;
+ default:
+ throw new Error("Bad overload");
+ break;
+ }
+ break;
+ case MoveDoubleConditionally32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, FP, 64);
+ inst.visitArg(4, func, Arg.Use, FP, 64);
+ inst.visitArg(5, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case MoveDoubleConditionally64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Use, FP, 64);
+ inst.visitArg(4, func, Arg.Use, FP, 64);
+ inst.visitArg(5, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case MoveDoubleConditionallyTest32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 32);
+ inst.visitArg(2, func, Arg.Use, GP, 32);
+ inst.visitArg(3, func, Arg.Use, FP, 64);
+ inst.visitArg(4, func, Arg.Use, FP, 64);
+ inst.visitArg(5, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case MoveDoubleConditionallyTest64:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, GP, 64);
+ inst.visitArg(2, func, Arg.Use, GP, 64);
+ inst.visitArg(3, func, Arg.Use, FP, 64);
+ inst.visitArg(4, func, Arg.Use, FP, 64);
+ inst.visitArg(5, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case MoveDoubleConditionallyDouble:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 64);
+ inst.visitArg(2, func, Arg.Use, FP, 64);
+ inst.visitArg(3, func, Arg.Use, FP, 64);
+ inst.visitArg(4, func, Arg.Use, FP, 64);
+ inst.visitArg(5, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case MoveDoubleConditionallyFloat:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ inst.visitArg(1, func, Arg.Use, FP, 32);
+ inst.visitArg(2, func, Arg.Use, FP, 32);
+ inst.visitArg(3, func, Arg.Use, FP, 64);
+ inst.visitArg(4, func, Arg.Use, FP, 64);
+ inst.visitArg(5, func, Arg.Def, FP, 64);
+ break;
+ break;
+ case Jump:
+ break;
+ break;
+ case Ret32:
+ inst.visitArg(0, func, Arg.Use, GP, 32);
+ break;
+ break;
+ case Ret64:
+ inst.visitArg(0, func, Arg.Use, GP, 64);
+ break;
+ break;
+ case RetFloat:
+ inst.visitArg(0, func, Arg.Use, FP, 32);
+ break;
+ break;
+ case RetDouble:
+ inst.visitArg(0, func, Arg.Use, FP, 64);
+ break;
+ break;
+ case Oops:
+ break;
+ break;
+ case Shuffle:
+ ShuffleCustom.forEachArg(inst, func);
+ break;
+ case Patch:
+ PatchCustom.forEachArg(inst, func);
+ break;
+ case CCall:
+ CCallCustom.forEachArg(inst, func);
+ break;
+ case ColdCCall:
+ ColdCCallCustom.forEachArg(inst, func);
+ break;
+ default:
+ throw "Bad opcode";
+ }
+}
+function Inst_hasNonArgEffects(inst)
+{
+ switch (inst.opcode) {
+ case Branch8:
+ case Branch32:
+ case Branch64:
+ case BranchTest8:
+ case BranchTest32:
+ case BranchTest64:
+ case BranchDouble:
+ case BranchFloat:
+ case BranchAdd32:
+ case BranchAdd64:
+ case BranchMul32:
+ case BranchMul64:
+ case BranchSub32:
+ case BranchSub64:
+ case BranchNeg32:
+ case BranchNeg64:
+ case Jump:
+ case Ret32:
+ case Ret64:
+ case RetFloat:
+ case RetDouble:
+ case Oops:
+ return true;
+ case Shuffle:
+ return ShuffleCustom.hasNonArgNonControlEffects(inst);
+ case Patch:
+ return PatchCustom.hasNonArgNonControlEffects(inst);
+ case CCall:
+ return CCallCustom.hasNonArgNonControlEffects(inst);
+ case ColdCCall:
+ return ColdCCallCustom.hasNonArgNonControlEffects(inst);
+ default:
+ return false;
+ }
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirpayloadgbemuexecuteIterationjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/payload-gbemu-executeIteration.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/payload-gbemu-executeIteration.js (rev 0)
+++ trunk/PerformanceTests/JSAir/payload-gbemu-executeIteration.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,3182 @@
</span><ins>+"use strict";
+// Generated by Air::dumpAsJS from executeIteration#EVx8pJ in Octane/gbemu
+function createPayloadGbemuExecuteIteration()
+{
+ let code = new Code();
+ let bb0 = code.addBlock();
+ let bb1 = code.addBlock();
+ let bb2 = code.addBlock();
+ let bb3 = code.addBlock();
+ let bb4 = code.addBlock();
+ let bb5 = code.addBlock();
+ let bb6 = code.addBlock();
+ let bb7 = code.addBlock();
+ let bb8 = code.addBlock();
+ let bb9 = code.addBlock();
+ let bb10 = code.addBlock();
+ let bb11 = code.addBlock();
+ let bb12 = code.addBlock();
+ let bb13 = code.addBlock();
+ let bb14 = code.addBlock();
+ let bb15 = code.addBlock();
+ let bb16 = code.addBlock();
+ let bb17 = code.addBlock();
+ let bb18 = code.addBlock();
+ let bb19 = code.addBlock();
+ let bb20 = code.addBlock();
+ let bb21 = code.addBlock();
+ let bb22 = code.addBlock();
+ let bb23 = code.addBlock();
+ let bb24 = code.addBlock();
+ let bb25 = code.addBlock();
+ let bb26 = code.addBlock();
+ let bb27 = code.addBlock();
+ let bb28 = code.addBlock();
+ let bb29 = code.addBlock();
+ let bb30 = code.addBlock();
+ let bb31 = code.addBlock();
+ let bb32 = code.addBlock();
+ let bb33 = code.addBlock();
+ let bb34 = code.addBlock();
+ let bb35 = code.addBlock();
+ let bb36 = code.addBlock();
+ let bb37 = code.addBlock();
+ let bb38 = code.addBlock();
+ let bb39 = code.addBlock();
+ let bb40 = code.addBlock();
+ let bb41 = code.addBlock();
+ let bb42 = code.addBlock();
+ let slot0 = code.addStackSlot(64, Locked);
+ let slot1 = code.addStackSlot(8, Spill);
+ let slot2 = code.addStackSlot(8, Spill);
+ let slot3 = code.addStackSlot(8, Spill);
+ let slot4 = code.addStackSlot(8, Spill);
+ let slot5 = code.addStackSlot(8, Spill);
+ let slot6 = code.addStackSlot(8, Spill);
+ let slot7 = code.addStackSlot(8, Spill);
+ let slot8 = code.addStackSlot(8, Spill);
+ let slot9 = code.addStackSlot(8, Spill);
+ let slot10 = code.addStackSlot(8, Spill);
+ let slot11 = code.addStackSlot(8, Spill);
+ let slot12 = code.addStackSlot(40, Locked);
+ let tmp190 = code.newTmp(GP);
+ let tmp189 = code.newTmp(GP);
+ let tmp188 = code.newTmp(GP);
+ let tmp187 = code.newTmp(GP);
+ let tmp186 = code.newTmp(GP);
+ let tmp185 = code.newTmp(GP);
+ let tmp184 = code.newTmp(GP);
+ let tmp183 = code.newTmp(GP);
+ let tmp182 = code.newTmp(GP);
+ let tmp181 = code.newTmp(GP);
+ let tmp180 = code.newTmp(GP);
+ let tmp179 = code.newTmp(GP);
+ let tmp178 = code.newTmp(GP);
+ let tmp177 = code.newTmp(GP);
+ let tmp176 = code.newTmp(GP);
+ let tmp175 = code.newTmp(GP);
+ let tmp174 = code.newTmp(GP);
+ let tmp173 = code.newTmp(GP);
+ let tmp172 = code.newTmp(GP);
+ let tmp171 = code.newTmp(GP);
+ let tmp170 = code.newTmp(GP);
+ let tmp169 = code.newTmp(GP);
+ let tmp168 = code.newTmp(GP);
+ let tmp167 = code.newTmp(GP);
+ let tmp166 = code.newTmp(GP);
+ let tmp165 = code.newTmp(GP);
+ let tmp164 = code.newTmp(GP);
+ let tmp163 = code.newTmp(GP);
+ let tmp162 = code.newTmp(GP);
+ let tmp161 = code.newTmp(GP);
+ let tmp160 = code.newTmp(GP);
+ let tmp159 = code.newTmp(GP);
+ let tmp158 = code.newTmp(GP);
+ let tmp157 = code.newTmp(GP);
+ let tmp156 = code.newTmp(GP);
+ let tmp155 = code.newTmp(GP);
+ let tmp154 = code.newTmp(GP);
+ let tmp153 = code.newTmp(GP);
+ let tmp152 = code.newTmp(GP);
+ let tmp151 = code.newTmp(GP);
+ let tmp150 = code.newTmp(GP);
+ let tmp149 = code.newTmp(GP);
+ let tmp148 = code.newTmp(GP);
+ let tmp147 = code.newTmp(GP);
+ let tmp146 = code.newTmp(GP);
+ let tmp145 = code.newTmp(GP);
+ let tmp144 = code.newTmp(GP);
+ let tmp143 = code.newTmp(GP);
+ let tmp142 = code.newTmp(GP);
+ let tmp141 = code.newTmp(GP);
+ let tmp140 = code.newTmp(GP);
+ let tmp139 = code.newTmp(GP);
+ let tmp138 = code.newTmp(GP);
+ let tmp137 = code.newTmp(GP);
+ let tmp136 = code.newTmp(GP);
+ let tmp135 = code.newTmp(GP);
+ let tmp134 = code.newTmp(GP);
+ let tmp133 = code.newTmp(GP);
+ let tmp132 = code.newTmp(GP);
+ let tmp131 = code.newTmp(GP);
+ let tmp130 = code.newTmp(GP);
+ let tmp129 = code.newTmp(GP);
+ let tmp128 = code.newTmp(GP);
+ let tmp127 = code.newTmp(GP);
+ let tmp126 = code.newTmp(GP);
+ let tmp125 = code.newTmp(GP);
+ let tmp124 = code.newTmp(GP);
+ let tmp123 = code.newTmp(GP);
+ let tmp122 = code.newTmp(GP);
+ let tmp121 = code.newTmp(GP);
+ let tmp120 = code.newTmp(GP);
+ let tmp119 = code.newTmp(GP);
+ let tmp118 = code.newTmp(GP);
+ let tmp117 = code.newTmp(GP);
+ let tmp116 = code.newTmp(GP);
+ let tmp115 = code.newTmp(GP);
+ let tmp114 = code.newTmp(GP);
+ let tmp113 = code.newTmp(GP);
+ let tmp112 = code.newTmp(GP);
+ let tmp111 = code.newTmp(GP);
+ let tmp110 = code.newTmp(GP);
+ let tmp109 = code.newTmp(GP);
+ let tmp108 = code.newTmp(GP);
+ let tmp107 = code.newTmp(GP);
+ let tmp106 = code.newTmp(GP);
+ let tmp105 = code.newTmp(GP);
+ let tmp104 = code.newTmp(GP);
+ let tmp103 = code.newTmp(GP);
+ let tmp102 = code.newTmp(GP);
+ let tmp101 = code.newTmp(GP);
+ let tmp100 = code.newTmp(GP);
+ let tmp99 = code.newTmp(GP);
+ let tmp98 = code.newTmp(GP);
+ let tmp97 = code.newTmp(GP);
+ let tmp96 = code.newTmp(GP);
+ let tmp95 = code.newTmp(GP);
+ let tmp94 = code.newTmp(GP);
+ let tmp93 = code.newTmp(GP);
+ let tmp92 = code.newTmp(GP);
+ let tmp91 = code.newTmp(GP);
+ let tmp90 = code.newTmp(GP);
+ let tmp89 = code.newTmp(GP);
+ let tmp88 = code.newTmp(GP);
+ let tmp87 = code.newTmp(GP);
+ let tmp86 = code.newTmp(GP);
+ let tmp85 = code.newTmp(GP);
+ let tmp84 = code.newTmp(GP);
+ let tmp83 = code.newTmp(GP);
+ let tmp82 = code.newTmp(GP);
+ let tmp81 = code.newTmp(GP);
+ let tmp80 = code.newTmp(GP);
+ let tmp79 = code.newTmp(GP);
+ let tmp78 = code.newTmp(GP);
+ let tmp77 = code.newTmp(GP);
+ let tmp76 = code.newTmp(GP);
+ let tmp75 = code.newTmp(GP);
+ let tmp74 = code.newTmp(GP);
+ let tmp73 = code.newTmp(GP);
+ let tmp72 = code.newTmp(GP);
+ let tmp71 = code.newTmp(GP);
+ let tmp70 = code.newTmp(GP);
+ let tmp69 = code.newTmp(GP);
+ let tmp68 = code.newTmp(GP);
+ let tmp67 = code.newTmp(GP);
+ let tmp66 = code.newTmp(GP);
+ let tmp65 = code.newTmp(GP);
+ let tmp64 = code.newTmp(GP);
+ let tmp63 = code.newTmp(GP);
+ let tmp62 = code.newTmp(GP);
+ let tmp61 = code.newTmp(GP);
+ let tmp60 = code.newTmp(GP);
+ let tmp59 = code.newTmp(GP);
+ let tmp58 = code.newTmp(GP);
+ let tmp57 = code.newTmp(GP);
+ let tmp56 = code.newTmp(GP);
+ let tmp55 = code.newTmp(GP);
+ let tmp54 = code.newTmp(GP);
+ let tmp53 = code.newTmp(GP);
+ let tmp52 = code.newTmp(GP);
+ let tmp51 = code.newTmp(GP);
+ let tmp50 = code.newTmp(GP);
+ let tmp49 = code.newTmp(GP);
+ let tmp48 = code.newTmp(GP);
+ let tmp47 = code.newTmp(GP);
+ let tmp46 = code.newTmp(GP);
+ let tmp45 = code.newTmp(GP);
+ let tmp44 = code.newTmp(GP);
+ let tmp43 = code.newTmp(GP);
+ let tmp42 = code.newTmp(GP);
+ let tmp41 = code.newTmp(GP);
+ let tmp40 = code.newTmp(GP);
+ let tmp39 = code.newTmp(GP);
+ let tmp38 = code.newTmp(GP);
+ let tmp37 = code.newTmp(GP);
+ let tmp36 = code.newTmp(GP);
+ let tmp35 = code.newTmp(GP);
+ let tmp34 = code.newTmp(GP);
+ let tmp33 = code.newTmp(GP);
+ let tmp32 = code.newTmp(GP);
+ let tmp31 = code.newTmp(GP);
+ let tmp30 = code.newTmp(GP);
+ let tmp29 = code.newTmp(GP);
+ let tmp28 = code.newTmp(GP);
+ let tmp27 = code.newTmp(GP);
+ let tmp26 = code.newTmp(GP);
+ let tmp25 = code.newTmp(GP);
+ let tmp24 = code.newTmp(GP);
+ let tmp23 = code.newTmp(GP);
+ let tmp22 = code.newTmp(GP);
+ let tmp21 = code.newTmp(GP);
+ let tmp20 = code.newTmp(GP);
+ let tmp19 = code.newTmp(GP);
+ let tmp18 = code.newTmp(GP);
+ let tmp17 = code.newTmp(GP);
+ let tmp16 = code.newTmp(GP);
+ let tmp15 = code.newTmp(GP);
+ let tmp14 = code.newTmp(GP);
+ let tmp13 = code.newTmp(GP);
+ let tmp12 = code.newTmp(GP);
+ let tmp11 = code.newTmp(GP);
+ let tmp10 = code.newTmp(GP);
+ let tmp9 = code.newTmp(GP);
+ let tmp8 = code.newTmp(GP);
+ let tmp7 = code.newTmp(GP);
+ let tmp6 = code.newTmp(GP);
+ let tmp5 = code.newTmp(GP);
+ let tmp4 = code.newTmp(GP);
+ let tmp3 = code.newTmp(GP);
+ let tmp2 = code.newTmp(GP);
+ let tmp1 = code.newTmp(GP);
+ let tmp0 = code.newTmp(GP);
+ let ftmp7 = code.newTmp(FP);
+ let ftmp6 = code.newTmp(FP);
+ let ftmp5 = code.newTmp(FP);
+ let ftmp4 = code.newTmp(FP);
+ let ftmp3 = code.newTmp(FP);
+ let ftmp2 = code.newTmp(FP);
+ let ftmp1 = code.newTmp(FP);
+ let ftmp0 = code.newTmp(FP);
+ let inst;
+ let arg;
+ bb0.successors.push(new FrequentedBlock(bb2, Normal));
+ bb0.successors.push(new FrequentedBlock(bb1, Normal));
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449751680);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 16);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Scratch, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710654);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(21);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createAddr(Reg.rbx, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449353264);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot7, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449959440);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot4, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449959448);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot11, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot3, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449352912);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot8, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4450056448);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot10, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710656);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449301888);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot6, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(281474976710656);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot9, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449321312);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot2, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449978064);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(862);
+ inst.args.push(arg);
+ bb0.append(inst);
+ bb1.successors.push(new FrequentedBlock(bb41, Normal));
+ bb1.successors.push(new FrequentedBlock(bb3, Normal));
+ bb1.predecessors.push(bb0);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(881);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb1.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 224);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb1.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb1.append(inst);
+ bb2.successors.push(new FrequentedBlock(bb41, Normal));
+ bb2.successors.push(new FrequentedBlock(bb3, Normal));
+ bb2.predecessors.push(bb0);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 224);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb2.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb2.append(inst);
+ bb3.successors.push(new FrequentedBlock(bb5, Normal));
+ bb3.successors.push(new FrequentedBlock(bb4, Normal));
+ bb3.predecessors.push(bb1);
+ bb3.predecessors.push(bb40);
+ bb3.predecessors.push(bb39);
+ bb3.predecessors.push(bb2);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb3.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1144);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb3.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ bb3.append(inst);
+ bb4.successors.push(new FrequentedBlock(bb6, Normal));
+ bb4.successors.push(new FrequentedBlock(bb7, Normal));
+ bb4.predecessors.push(bb3);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ bb4.append(inst);
+ bb5.successors.push(new FrequentedBlock(bb6, Normal));
+ bb5.predecessors.push(bb3);
+ inst = new Inst(Move);
+ arg = Arg.createImm(7);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 232);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 256);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 248);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(And32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(And32);
+ arg = Arg.createImm(31);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 240);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Jump);
+ bb5.append(inst);
+ bb6.successors.push(new FrequentedBlock(bb7, Normal));
+ bb6.predecessors.push(bb4);
+ bb6.predecessors.push(bb5);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1144);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Jump);
+ bb6.append(inst);
+ bb7.successors.push(new FrequentedBlock(bb8, Normal));
+ bb7.successors.push(new FrequentedBlock(bb9, Normal));
+ bb7.predecessors.push(bb4);
+ bb7.predecessors.push(bb6);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 240);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ bb7.append(inst);
+ bb8.successors.push(new FrequentedBlock(bb9, Normal));
+ bb8.predecessors.push(bb7);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449301888);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449301888);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb8.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb8.append(inst);
+ inst = new Inst(Jump);
+ bb8.append(inst);
+ bb9.successors.push(new FrequentedBlock(bb12, Normal));
+ bb9.successors.push(new FrequentedBlock(bb10, Normal));
+ bb9.predecessors.push(bb7);
+ bb9.predecessors.push(bb8);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 304);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 128);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.r8, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(80);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb9.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r8, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb9.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createIndex(Reg.rax, Reg.rsi, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(MoveConditionallyTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb9.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(23);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb9.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rcx, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot8, 0);
+ inst.args.push(arg);
+ bb9.append(inst);
+ bb10.successors.push(new FrequentedBlock(bb11, Normal));
+ bb10.successors.push(new FrequentedBlock(bb13, Normal));
+ bb10.predecessors.push(bb9);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot7, 0);
+ inst.args.push(arg);
+ bb10.append(inst);
+ bb11.successors.push(new FrequentedBlock(bb14, Normal));
+ bb11.predecessors.push(bb10);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 0);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 344);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(502);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdi, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb11.append(inst);
+ inst = new Inst(Load8);
+ arg = Arg.createIndex(Reg.rsi, Reg.rax, 1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Jump);
+ bb11.append(inst);
+ bb12.successors.push(new FrequentedBlock(bb14, Normal));
+ bb12.predecessors.push(bb9);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 0);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 336);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 456);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb12.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(502);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb12.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdi, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb12.append(inst);
+ inst = new Inst(Load8);
+ arg = Arg.createIndex(Reg.rsi, Reg.rax, 1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(Jump);
+ bb12.append(inst);
+ bb13.predecessors.push(bb10);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb13.append(inst);
+ inst = new Inst(Oops);
+ bb13.append(inst);
+ bb14.successors.push(new FrequentedBlock(bb15, Normal));
+ bb14.successors.push(new FrequentedBlock(bb16, Normal));
+ bb14.predecessors.push(bb11);
+ bb14.predecessors.push(bb12);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(ZeroExtend16To32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 128);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 216);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ bb14.append(inst);
+ bb15.predecessors.push(bb14);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb15.append(inst);
+ inst = new Inst(Oops);
+ bb15.append(inst);
+ bb16.successors.push(new FrequentedBlock(bb18, Normal));
+ bb16.successors.push(new FrequentedBlock(bb17, Normal));
+ bb16.predecessors.push(bb14);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, -1752);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdx, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdx, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Load8);
+ arg = Arg.createIndex(Reg.rax, Reg.rcx, 1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 272);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449959440);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(80);
+ inst.args.push(arg);
+ arg = Arg.createBigImm(4449959440);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449959448);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createIndex(Reg.rax, Reg.rcx, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(MoveConditionallyTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449959440);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdx, -1088);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 272);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 280);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Rshift32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb16.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdx, -1088);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdx, -88);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdx, -1176);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(80);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rcx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb16.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createIndex(Reg.rax, Reg.rdx, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(MoveConditionallyTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(23);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 272);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 280);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Rshift32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1048);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb16.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1048);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1072);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb16.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ bb16.append(inst);
+ bb17.successors.push(new FrequentedBlock(bb19, Normal));
+ bb17.predecessors.push(bb16);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb17.append(inst);
+ inst = new Inst(Jump);
+ bb17.append(inst);
+ bb18.successors.push(new FrequentedBlock(bb19, Normal));
+ bb18.predecessors.push(bb16);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb18.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb18.append(inst);
+ inst = new Inst(Jump);
+ bb18.append(inst);
+ bb19.successors.push(new FrequentedBlock(bb20, Normal));
+ bb19.successors.push(new FrequentedBlock(bb32, Normal));
+ bb19.predecessors.push(bb17);
+ bb19.predecessors.push(bb18);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(AddDouble);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(MoveDoubleTo64);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(281474976710656);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1072);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1080);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb19.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1080);
+ inst.args.push(arg);
+ bb19.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1104);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ bb19.append(inst);
+ bb20.successors.push(new FrequentedBlock(bb21, Normal));
+ bb20.successors.push(new FrequentedBlock(bb32, Normal));
+ bb20.predecessors.push(bb19);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1096);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb20.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1096);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1112);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb20.append(inst);
+ bb21.successors.push(new FrequentedBlock(bb23, Normal));
+ bb21.predecessors.push(bb20);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 344);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ bb21.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.r12, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(502);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb21.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r12, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb21.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createAddr(Reg.r12, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ bb21.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(BelowOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createImm(65286);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb21.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 232);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ bb21.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 256);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb21.append(inst);
+ inst = new Inst(Jump);
+ bb21.append(inst);
+ bb22.successors.push(new FrequentedBlock(bb23, Normal));
+ bb22.predecessors.push(bb30);
+ bb22.predecessors.push(bb31);
+ bb22.predecessors.push(bb29);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb22.append(inst);
+ inst = new Inst(Jump);
+ bb22.append(inst);
+ bb23.successors.push(new FrequentedBlock(bb25, Normal));
+ bb23.successors.push(new FrequentedBlock(bb24, Normal));
+ bb23.predecessors.push(bb21);
+ bb23.predecessors.push(bb22);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb23.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rsi, -1096);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Load8);
+ arg = Arg.createAddr(Reg.rdi, 65285);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb23.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(BelowOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createImm(65285);
+ inst.args.push(arg);
+ bb23.append(inst);
+ bb24.successors.push(new FrequentedBlock(bb26, Normal));
+ bb24.successors.push(new FrequentedBlock(bb30, Normal));
+ bb24.predecessors.push(bb23);
+ inst = new Inst(Store8);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 65285);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createImm(256);
+ inst.args.push(arg);
+ bb24.append(inst);
+ bb25.successors.push(new FrequentedBlock(bb26, Normal));
+ bb25.successors.push(new FrequentedBlock(bb30, Normal));
+ bb25.predecessors.push(bb23);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createImm(256);
+ inst.args.push(arg);
+ bb25.append(inst);
+ bb26.successors.push(new FrequentedBlock(bb28, Normal));
+ bb26.successors.push(new FrequentedBlock(bb27, Normal));
+ bb26.predecessors.push(bb24);
+ bb26.predecessors.push(bb25);
+ inst = new Inst(Load8);
+ arg = Arg.createAddr(Reg.rdi, 65286);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb26.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(BelowOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createImm(65285);
+ inst.args.push(arg);
+ bb26.append(inst);
+ bb27.successors.push(new FrequentedBlock(bb28, Normal));
+ bb27.predecessors.push(bb26);
+ inst = new Inst(Store8);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 65285);
+ inst.args.push(arg);
+ bb27.append(inst);
+ inst = new Inst(Jump);
+ bb27.append(inst);
+ bb28.successors.push(new FrequentedBlock(bb29, Normal));
+ bb28.successors.push(new FrequentedBlock(bb31, Normal));
+ bb28.predecessors.push(bb26);
+ bb28.predecessors.push(bb27);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 248);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb28.append(inst);
+ inst = new Inst(Or32);
+ arg = Arg.createImm(4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb28.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb28.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb28.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 248);
+ inst.args.push(arg);
+ bb28.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb28.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb28.append(inst);
+ bb29.successors.push(new FrequentedBlock(bb22, Normal));
+ bb29.successors.push(new FrequentedBlock(bb32, Normal));
+ bb29.predecessors.push(bb28);
+ inst = new Inst(And32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb29.append(inst);
+ inst = new Inst(And32);
+ arg = Arg.createImm(31);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb29.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb29.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 240);
+ inst.args.push(arg);
+ bb29.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb29.append(inst);
+ bb30.successors.push(new FrequentedBlock(bb22, Normal));
+ bb30.successors.push(new FrequentedBlock(bb32, Normal));
+ bb30.predecessors.push(bb24);
+ bb30.predecessors.push(bb25);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb30.append(inst);
+ bb31.successors.push(new FrequentedBlock(bb22, Normal));
+ bb31.successors.push(new FrequentedBlock(bb32, Normal));
+ bb31.predecessors.push(bb28);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb31.append(inst);
+ bb32.successors.push(new FrequentedBlock(bb33, Normal));
+ bb32.successors.push(new FrequentedBlock(bb34, Normal));
+ bb32.predecessors.push(bb19);
+ bb32.predecessors.push(bb20);
+ bb32.predecessors.push(bb30);
+ bb32.predecessors.push(bb31);
+ bb32.predecessors.push(bb29);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rsi, -1120);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ bb32.append(inst);
+ bb33.predecessors.push(bb32);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb33.append(inst);
+ inst = new Inst(Oops);
+ bb33.append(inst);
+ bb34.successors.push(new FrequentedBlock(bb36, Normal));
+ bb34.successors.push(new FrequentedBlock(bb35, Normal));
+ bb34.predecessors.push(bb32);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 136);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ bb34.append(inst);
+ bb35.successors.push(new FrequentedBlock(bb37, Normal));
+ bb35.successors.push(new FrequentedBlock(bb38, Normal));
+ bb35.predecessors.push(bb34);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb35.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleGreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb35.append(inst);
+ bb36.successors.push(new FrequentedBlock(bb37, Normal));
+ bb36.successors.push(new FrequentedBlock(bb38, Normal));
+ bb36.predecessors.push(bb34);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb36.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb36.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleGreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb36.append(inst);
+ bb37.successors.push(new FrequentedBlock(bb38, Normal));
+ bb37.predecessors.push(bb35);
+ bb37.predecessors.push(bb36);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449321312);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb37.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449321312);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb37.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb37.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb37.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb37.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb37.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb37.append(inst);
+ inst = new Inst(Jump);
+ bb37.append(inst);
+ bb38.successors.push(new FrequentedBlock(bb39, Normal));
+ bb38.successors.push(new FrequentedBlock(bb40, Normal));
+ bb38.predecessors.push(bb35);
+ bb38.predecessors.push(bb37);
+ bb38.predecessors.push(bb36);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(881);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb38.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdx, -1824);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb38.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdx, -1824);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdx, -1832);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb38.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb38.append(inst);
+ bb39.successors.push(new FrequentedBlock(bb42, Normal));
+ bb39.successors.push(new FrequentedBlock(bb3, Normal));
+ bb39.predecessors.push(bb38);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449321312);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449321312);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb39.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 224);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Or32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 224);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449978064);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4449978064);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4450056448);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb39.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb39.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 224);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb39.append(inst);
+ bb40.successors.push(new FrequentedBlock(bb42, Normal));
+ bb40.successors.push(new FrequentedBlock(bb3, Normal));
+ bb40.predecessors.push(bb38);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 224);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb40.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb40.append(inst);
+ bb41.predecessors.push(bb1);
+ bb41.predecessors.push(bb2);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb41.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb41.append(inst);
+ bb42.predecessors.push(bb40);
+ bb42.predecessors.push(bb39);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb42.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb42.append(inst);
+ return code;
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirpayloadimaginggaussianblurgaussianBlurjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/payload-imaging-gaussian-blur-gaussianBlur.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/payload-imaging-gaussian-blur-gaussianBlur.js (rev 0)
+++ trunk/PerformanceTests/JSAir/payload-imaging-gaussian-blur-gaussianBlur.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,3064 @@
</span><ins>+"use strict";
+// Generated by Air::dumpAsJS from gaussianBlur#A8vcYg in Kraken/imaging-gaussian-blur
+function createPayloadImagingGaussianBlurGaussianBlur()
+{
+ let code = new Code();
+ let bb0 = code.addBlock();
+ let bb1 = code.addBlock();
+ let bb2 = code.addBlock();
+ let bb3 = code.addBlock();
+ let bb4 = code.addBlock();
+ let bb5 = code.addBlock();
+ let bb6 = code.addBlock();
+ let bb7 = code.addBlock();
+ let bb8 = code.addBlock();
+ let bb9 = code.addBlock();
+ let bb10 = code.addBlock();
+ let bb11 = code.addBlock();
+ let bb12 = code.addBlock();
+ let bb13 = code.addBlock();
+ let bb14 = code.addBlock();
+ let bb15 = code.addBlock();
+ let bb16 = code.addBlock();
+ let bb17 = code.addBlock();
+ let bb18 = code.addBlock();
+ let bb19 = code.addBlock();
+ let bb20 = code.addBlock();
+ let bb21 = code.addBlock();
+ let bb22 = code.addBlock();
+ let bb23 = code.addBlock();
+ let bb24 = code.addBlock();
+ let bb25 = code.addBlock();
+ let bb26 = code.addBlock();
+ let bb27 = code.addBlock();
+ let bb28 = code.addBlock();
+ let bb29 = code.addBlock();
+ let bb30 = code.addBlock();
+ let bb31 = code.addBlock();
+ let bb32 = code.addBlock();
+ let bb33 = code.addBlock();
+ let bb34 = code.addBlock();
+ let bb35 = code.addBlock();
+ let bb36 = code.addBlock();
+ let slot0 = code.addStackSlot(40, Locked);
+ let slot1 = code.addStackSlot(8, Spill);
+ let slot2 = code.addStackSlot(8, Spill);
+ let slot3 = code.addStackSlot(4, Spill);
+ let slot4 = code.addStackSlot(8, Spill);
+ let slot5 = code.addStackSlot(8, Spill);
+ let slot6 = code.addStackSlot(40, Locked);
+ let tmp141 = code.newTmp(GP);
+ let tmp140 = code.newTmp(GP);
+ let tmp139 = code.newTmp(GP);
+ let tmp138 = code.newTmp(GP);
+ let tmp137 = code.newTmp(GP);
+ let tmp136 = code.newTmp(GP);
+ let tmp135 = code.newTmp(GP);
+ let tmp134 = code.newTmp(GP);
+ let tmp133 = code.newTmp(GP);
+ let tmp132 = code.newTmp(GP);
+ let tmp131 = code.newTmp(GP);
+ let tmp130 = code.newTmp(GP);
+ let tmp129 = code.newTmp(GP);
+ let tmp128 = code.newTmp(GP);
+ let tmp127 = code.newTmp(GP);
+ let tmp126 = code.newTmp(GP);
+ let tmp125 = code.newTmp(GP);
+ let tmp124 = code.newTmp(GP);
+ let tmp123 = code.newTmp(GP);
+ let tmp122 = code.newTmp(GP);
+ let tmp121 = code.newTmp(GP);
+ let tmp120 = code.newTmp(GP);
+ let tmp119 = code.newTmp(GP);
+ let tmp118 = code.newTmp(GP);
+ let tmp117 = code.newTmp(GP);
+ let tmp116 = code.newTmp(GP);
+ let tmp115 = code.newTmp(GP);
+ let tmp114 = code.newTmp(GP);
+ let tmp113 = code.newTmp(GP);
+ let tmp112 = code.newTmp(GP);
+ let tmp111 = code.newTmp(GP);
+ let tmp110 = code.newTmp(GP);
+ let tmp109 = code.newTmp(GP);
+ let tmp108 = code.newTmp(GP);
+ let tmp107 = code.newTmp(GP);
+ let tmp106 = code.newTmp(GP);
+ let tmp105 = code.newTmp(GP);
+ let tmp104 = code.newTmp(GP);
+ let tmp103 = code.newTmp(GP);
+ let tmp102 = code.newTmp(GP);
+ let tmp101 = code.newTmp(GP);
+ let tmp100 = code.newTmp(GP);
+ let tmp99 = code.newTmp(GP);
+ let tmp98 = code.newTmp(GP);
+ let tmp97 = code.newTmp(GP);
+ let tmp96 = code.newTmp(GP);
+ let tmp95 = code.newTmp(GP);
+ let tmp94 = code.newTmp(GP);
+ let tmp93 = code.newTmp(GP);
+ let tmp92 = code.newTmp(GP);
+ let tmp91 = code.newTmp(GP);
+ let tmp90 = code.newTmp(GP);
+ let tmp89 = code.newTmp(GP);
+ let tmp88 = code.newTmp(GP);
+ let tmp87 = code.newTmp(GP);
+ let tmp86 = code.newTmp(GP);
+ let tmp85 = code.newTmp(GP);
+ let tmp84 = code.newTmp(GP);
+ let tmp83 = code.newTmp(GP);
+ let tmp82 = code.newTmp(GP);
+ let tmp81 = code.newTmp(GP);
+ let tmp80 = code.newTmp(GP);
+ let tmp79 = code.newTmp(GP);
+ let tmp78 = code.newTmp(GP);
+ let tmp77 = code.newTmp(GP);
+ let tmp76 = code.newTmp(GP);
+ let tmp75 = code.newTmp(GP);
+ let tmp74 = code.newTmp(GP);
+ let tmp73 = code.newTmp(GP);
+ let tmp72 = code.newTmp(GP);
+ let tmp71 = code.newTmp(GP);
+ let tmp70 = code.newTmp(GP);
+ let tmp69 = code.newTmp(GP);
+ let tmp68 = code.newTmp(GP);
+ let tmp67 = code.newTmp(GP);
+ let tmp66 = code.newTmp(GP);
+ let tmp65 = code.newTmp(GP);
+ let tmp64 = code.newTmp(GP);
+ let tmp63 = code.newTmp(GP);
+ let tmp62 = code.newTmp(GP);
+ let tmp61 = code.newTmp(GP);
+ let tmp60 = code.newTmp(GP);
+ let tmp59 = code.newTmp(GP);
+ let tmp58 = code.newTmp(GP);
+ let tmp57 = code.newTmp(GP);
+ let tmp56 = code.newTmp(GP);
+ let tmp55 = code.newTmp(GP);
+ let tmp54 = code.newTmp(GP);
+ let tmp53 = code.newTmp(GP);
+ let tmp52 = code.newTmp(GP);
+ let tmp51 = code.newTmp(GP);
+ let tmp50 = code.newTmp(GP);
+ let tmp49 = code.newTmp(GP);
+ let tmp48 = code.newTmp(GP);
+ let tmp47 = code.newTmp(GP);
+ let tmp46 = code.newTmp(GP);
+ let tmp45 = code.newTmp(GP);
+ let tmp44 = code.newTmp(GP);
+ let tmp43 = code.newTmp(GP);
+ let tmp42 = code.newTmp(GP);
+ let tmp41 = code.newTmp(GP);
+ let tmp40 = code.newTmp(GP);
+ let tmp39 = code.newTmp(GP);
+ let tmp38 = code.newTmp(GP);
+ let tmp37 = code.newTmp(GP);
+ let tmp36 = code.newTmp(GP);
+ let tmp35 = code.newTmp(GP);
+ let tmp34 = code.newTmp(GP);
+ let tmp33 = code.newTmp(GP);
+ let tmp32 = code.newTmp(GP);
+ let tmp31 = code.newTmp(GP);
+ let tmp30 = code.newTmp(GP);
+ let tmp29 = code.newTmp(GP);
+ let tmp28 = code.newTmp(GP);
+ let tmp27 = code.newTmp(GP);
+ let tmp26 = code.newTmp(GP);
+ let tmp25 = code.newTmp(GP);
+ let tmp24 = code.newTmp(GP);
+ let tmp23 = code.newTmp(GP);
+ let tmp22 = code.newTmp(GP);
+ let tmp21 = code.newTmp(GP);
+ let tmp20 = code.newTmp(GP);
+ let tmp19 = code.newTmp(GP);
+ let tmp18 = code.newTmp(GP);
+ let tmp17 = code.newTmp(GP);
+ let tmp16 = code.newTmp(GP);
+ let tmp15 = code.newTmp(GP);
+ let tmp14 = code.newTmp(GP);
+ let tmp13 = code.newTmp(GP);
+ let tmp12 = code.newTmp(GP);
+ let tmp11 = code.newTmp(GP);
+ let tmp10 = code.newTmp(GP);
+ let tmp9 = code.newTmp(GP);
+ let tmp8 = code.newTmp(GP);
+ let tmp7 = code.newTmp(GP);
+ let tmp6 = code.newTmp(GP);
+ let tmp5 = code.newTmp(GP);
+ let tmp4 = code.newTmp(GP);
+ let tmp3 = code.newTmp(GP);
+ let tmp2 = code.newTmp(GP);
+ let tmp1 = code.newTmp(GP);
+ let tmp0 = code.newTmp(GP);
+ let ftmp74 = code.newTmp(FP);
+ let ftmp73 = code.newTmp(FP);
+ let ftmp72 = code.newTmp(FP);
+ let ftmp71 = code.newTmp(FP);
+ let ftmp70 = code.newTmp(FP);
+ let ftmp69 = code.newTmp(FP);
+ let ftmp68 = code.newTmp(FP);
+ let ftmp67 = code.newTmp(FP);
+ let ftmp66 = code.newTmp(FP);
+ let ftmp65 = code.newTmp(FP);
+ let ftmp64 = code.newTmp(FP);
+ let ftmp63 = code.newTmp(FP);
+ let ftmp62 = code.newTmp(FP);
+ let ftmp61 = code.newTmp(FP);
+ let ftmp60 = code.newTmp(FP);
+ let ftmp59 = code.newTmp(FP);
+ let ftmp58 = code.newTmp(FP);
+ let ftmp57 = code.newTmp(FP);
+ let ftmp56 = code.newTmp(FP);
+ let ftmp55 = code.newTmp(FP);
+ let ftmp54 = code.newTmp(FP);
+ let ftmp53 = code.newTmp(FP);
+ let ftmp52 = code.newTmp(FP);
+ let ftmp51 = code.newTmp(FP);
+ let ftmp50 = code.newTmp(FP);
+ let ftmp49 = code.newTmp(FP);
+ let ftmp48 = code.newTmp(FP);
+ let ftmp47 = code.newTmp(FP);
+ let ftmp46 = code.newTmp(FP);
+ let ftmp45 = code.newTmp(FP);
+ let ftmp44 = code.newTmp(FP);
+ let ftmp43 = code.newTmp(FP);
+ let ftmp42 = code.newTmp(FP);
+ let ftmp41 = code.newTmp(FP);
+ let ftmp40 = code.newTmp(FP);
+ let ftmp39 = code.newTmp(FP);
+ let ftmp38 = code.newTmp(FP);
+ let ftmp37 = code.newTmp(FP);
+ let ftmp36 = code.newTmp(FP);
+ let ftmp35 = code.newTmp(FP);
+ let ftmp34 = code.newTmp(FP);
+ let ftmp33 = code.newTmp(FP);
+ let ftmp32 = code.newTmp(FP);
+ let ftmp31 = code.newTmp(FP);
+ let ftmp30 = code.newTmp(FP);
+ let ftmp29 = code.newTmp(FP);
+ let ftmp28 = code.newTmp(FP);
+ let ftmp27 = code.newTmp(FP);
+ let ftmp26 = code.newTmp(FP);
+ let ftmp25 = code.newTmp(FP);
+ let ftmp24 = code.newTmp(FP);
+ let ftmp23 = code.newTmp(FP);
+ let ftmp22 = code.newTmp(FP);
+ let ftmp21 = code.newTmp(FP);
+ let ftmp20 = code.newTmp(FP);
+ let ftmp19 = code.newTmp(FP);
+ let ftmp18 = code.newTmp(FP);
+ let ftmp17 = code.newTmp(FP);
+ let ftmp16 = code.newTmp(FP);
+ let ftmp15 = code.newTmp(FP);
+ let ftmp14 = code.newTmp(FP);
+ let ftmp13 = code.newTmp(FP);
+ let ftmp12 = code.newTmp(FP);
+ let ftmp11 = code.newTmp(FP);
+ let ftmp10 = code.newTmp(FP);
+ let ftmp9 = code.newTmp(FP);
+ let ftmp8 = code.newTmp(FP);
+ let ftmp7 = code.newTmp(FP);
+ let ftmp6 = code.newTmp(FP);
+ let ftmp5 = code.newTmp(FP);
+ let ftmp4 = code.newTmp(FP);
+ let ftmp3 = code.newTmp(FP);
+ let ftmp2 = code.newTmp(FP);
+ let ftmp1 = code.newTmp(FP);
+ let ftmp0 = code.newTmp(FP);
+ let inst;
+ let arg;
+ bb0.successors.push(new FrequentedBlock(bb2, Normal));
+ bb0.successors.push(new FrequentedBlock(bb1, Rare));
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4374261488);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 16);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Scratch, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502752);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502768);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502776);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502784);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502792);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502800);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502808);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502816);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4372502824);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710656);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ bb0.append(inst);
+ bb1.successors.push(new FrequentedBlock(bb2, Normal));
+ bb1.predecessors.push(bb0);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb1.append(inst);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ bb1.append(inst);
+ inst = new Inst(Jump);
+ bb1.append(inst);
+ bb2.successors.push(new FrequentedBlock(bb4, Normal));
+ bb2.successors.push(new FrequentedBlock(bb3, Rare));
+ bb2.predecessors.push(bb0);
+ bb2.predecessors.push(bb1);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb2.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb2.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb2.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb2.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ bb2.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ bb2.append(inst);
+ bb3.successors.push(new FrequentedBlock(bb4, Normal));
+ bb3.predecessors.push(bb2);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb3.append(inst);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ bb3.append(inst);
+ inst = new Inst(Jump);
+ bb3.append(inst);
+ bb4.successors.push(new FrequentedBlock(bb6, Normal));
+ bb4.successors.push(new FrequentedBlock(bb5, Rare));
+ bb4.predecessors.push(bb2);
+ bb4.predecessors.push(bb3);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb4.append(inst);
+ bb5.successors.push(new FrequentedBlock(bb6, Normal));
+ bb5.predecessors.push(bb4);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Jump);
+ bb5.append(inst);
+ bb6.successors.push(new FrequentedBlock(bb8, Normal));
+ bb6.successors.push(new FrequentedBlock(bb7, Rare));
+ bb6.predecessors.push(bb4);
+ bb6.predecessors.push(bb5);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb6.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ bb6.append(inst);
+ bb7.successors.push(new FrequentedBlock(bb8, Normal));
+ bb7.predecessors.push(bb6);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb7.append(inst);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Jump);
+ bb7.append(inst);
+ bb8.successors.push(new FrequentedBlock(bb10, Normal));
+ bb8.successors.push(new FrequentedBlock(bb9, Rare));
+ bb8.predecessors.push(bb6);
+ bb8.predecessors.push(bb7);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4347049352);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Move64ToDouble);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(BranchDouble);
+ arg = Arg.createDoubleCond(DoubleEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ bb8.append(inst);
+ bb9.successors.push(new FrequentedBlock(bb10, Normal));
+ bb9.predecessors.push(bb8);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb9.append(inst);
+ inst = new Inst(ConvertInt32ToDouble);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Jump);
+ bb9.append(inst);
+ bb10.successors.push(new FrequentedBlock(bb18, Normal));
+ bb10.predecessors.push(bb8);
+ bb10.predecessors.push(bb9);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4374462168);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createAddr(Reg.r9, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4374462128);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(80);
+ inst.args.push(arg);
+ arg = Arg.createBigImm(4374462128);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4374462136);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot2, 0);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createAddr(Reg.rdi, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot3, 0);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(MoveZeroToDouble);
+ arg = Arg.createTmp(Reg.xmm7);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot4, 0);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710654);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Jump);
+ bb10.append(inst);
+ bb11.successors.push(new FrequentedBlock(bb13, Normal));
+ bb11.predecessors.push(bb35);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Jump);
+ bb11.append(inst);
+ bb12.successors.push(new FrequentedBlock(bb13, Normal));
+ bb12.predecessors.push(bb34);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(Jump);
+ bb12.append(inst);
+ bb13.successors.push(new FrequentedBlock(bb15, Normal));
+ bb13.predecessors.push(bb11);
+ bb13.predecessors.push(bb12);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb13.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm7);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb13.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm7);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ bb13.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm7);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ bb13.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm7);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ bb13.append(inst);
+ inst = new Inst(Jump);
+ bb13.append(inst);
+ bb14.successors.push(new FrequentedBlock(bb15, Normal));
+ bb14.predecessors.push(bb31);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(Jump);
+ bb14.append(inst);
+ bb15.successors.push(new FrequentedBlock(bb28, Normal));
+ bb15.successors.push(new FrequentedBlock(bb16, Normal));
+ bb15.predecessors.push(bb13);
+ bb15.predecessors.push(bb14);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb15.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ bb15.append(inst);
+ bb16.successors.push(new FrequentedBlock(bb29, Normal));
+ bb16.successors.push(new FrequentedBlock(bb17, Normal));
+ bb16.predecessors.push(bb15);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(267);
+ inst.args.push(arg);
+ bb16.append(inst);
+ bb17.successors.push(new FrequentedBlock(bb18, Normal));
+ bb17.predecessors.push(bb16);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb17.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb17.append(inst);
+ inst = new Inst(Jump);
+ bb17.append(inst);
+ bb18.successors.push(new FrequentedBlock(bb20, Normal));
+ bb18.successors.push(new FrequentedBlock(bb19, Rare));
+ bb18.predecessors.push(bb10);
+ bb18.predecessors.push(bb17);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ bb18.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb18.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(400);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb18.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb18.append(inst);
+ bb19.successors.push(new FrequentedBlock(bb20, Normal));
+ bb19.predecessors.push(bb18);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb19.append(inst);
+ inst = new Inst(Jump);
+ bb19.append(inst);
+ bb20.successors.push(new FrequentedBlock(bb22, Normal));
+ bb20.predecessors.push(bb18);
+ bb20.predecessors.push(bb19);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Rshift32);
+ arg = Arg.createImm(31);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Xor32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb20.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot3, 0);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb20.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createStack(slot2, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createIndex(Reg.rsi, Reg.rdi, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(MoveConditionallyTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb20.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rdi, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(79);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb20.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rdi, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createAddr(Reg.r12, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb20.append(inst);
+ inst = new Inst(Jump);
+ bb20.append(inst);
+ bb21.successors.push(new FrequentedBlock(bb22, Normal));
+ bb21.predecessors.push(bb27);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb21.append(inst);
+ inst = new Inst(Jump);
+ bb21.append(inst);
+ bb22.successors.push(new FrequentedBlock(bb25, Normal));
+ bb22.successors.push(new FrequentedBlock(bb23, Normal));
+ bb22.predecessors.push(bb20);
+ bb22.predecessors.push(bb21);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb22.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ bb22.append(inst);
+ bb23.successors.push(new FrequentedBlock(bb26, Normal));
+ bb23.successors.push(new FrequentedBlock(bb24, Normal));
+ bb23.predecessors.push(bb22);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(400);
+ inst.args.push(arg);
+ bb23.append(inst);
+ bb24.successors.push(new FrequentedBlock(bb27, Normal));
+ bb24.predecessors.push(bb23);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb24.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createImm(4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb24.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb24.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb24.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createIndex(Reg.r9, Reg.r15, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Rshift32);
+ arg = Arg.createImm(31);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Xor32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb24.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb24.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createIndex(Reg.r12, Reg.rbx, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(MulDouble);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(AddDouble);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(MulDouble);
+ arg = Arg.createIndex(Reg.r9, Reg.rsi, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(AddDouble);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(MulDouble);
+ arg = Arg.createIndex(Reg.r9, Reg.r15, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(AddDouble);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(MulDouble);
+ arg = Arg.createIndex(Reg.r9, Reg.r14, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(AddDouble);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ bb24.append(inst);
+ inst = new Inst(Jump);
+ bb24.append(inst);
+ bb25.successors.push(new FrequentedBlock(bb27, Normal));
+ bb25.predecessors.push(bb22);
+ inst = new Inst(Jump);
+ bb25.append(inst);
+ bb26.successors.push(new FrequentedBlock(bb27, Normal));
+ bb26.predecessors.push(bb23);
+ inst = new Inst(Jump);
+ bb26.append(inst);
+ bb27.successors.push(new FrequentedBlock(bb21, Normal));
+ bb27.successors.push(new FrequentedBlock(bb30, Normal));
+ bb27.predecessors.push(bb24);
+ bb27.predecessors.push(bb26);
+ bb27.predecessors.push(bb25);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb27.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb27.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(7);
+ inst.args.push(arg);
+ bb27.append(inst);
+ bb28.successors.push(new FrequentedBlock(bb31, Normal));
+ bb28.predecessors.push(bb15);
+ inst = new Inst(Jump);
+ bb28.append(inst);
+ bb29.successors.push(new FrequentedBlock(bb31, Normal));
+ bb29.predecessors.push(bb16);
+ inst = new Inst(Jump);
+ bb29.append(inst);
+ bb30.successors.push(new FrequentedBlock(bb31, Normal));
+ bb30.predecessors.push(bb27);
+ inst = new Inst(Move);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb30.append(inst);
+ inst = new Inst(Jump);
+ bb30.append(inst);
+ bb31.successors.push(new FrequentedBlock(bb14, Normal));
+ bb31.successors.push(new FrequentedBlock(bb32, Normal));
+ bb31.predecessors.push(bb30);
+ bb31.predecessors.push(bb29);
+ bb31.predecessors.push(bb28);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb31.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb31.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(7);
+ inst.args.push(arg);
+ bb31.append(inst);
+ bb32.successors.push(new FrequentedBlock(bb34, Normal));
+ bb32.successors.push(new FrequentedBlock(bb33, Rare));
+ bb32.predecessors.push(bb31);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createImm(400);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ bb32.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb32.append(inst);
+ bb33.successors.push(new FrequentedBlock(bb34, Normal));
+ bb33.predecessors.push(bb32);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createImm(0);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb33.append(inst);
+ inst = new Inst(Jump);
+ bb33.append(inst);
+ bb34.successors.push(new FrequentedBlock(bb12, Normal));
+ bb34.successors.push(new FrequentedBlock(bb35, Normal));
+ bb34.predecessors.push(bb32);
+ bb34.predecessors.push(bb33);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createImm(4);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb34.append(inst);
+ inst = new Inst(DivDouble);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm1);
+ inst.args.push(arg);
+ arg = Arg.createIndex(Reg.r9, Reg.rsi, 8, 0);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb34.append(inst);
+ inst = new Inst(DivDouble);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm2);
+ inst.args.push(arg);
+ arg = Arg.createIndex(Reg.r9, Reg.rdi, 8, 0);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Add32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(DivDouble);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm3);
+ inst.args.push(arg);
+ arg = Arg.createIndex(Reg.r9, Reg.rsi, 8, 0);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(DivDouble);
+ arg = Arg.createTmp(Reg.xmm6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(MoveDouble);
+ arg = Arg.createTmp(Reg.xmm5);
+ inst.args.push(arg);
+ arg = Arg.createIndex(Reg.r9, Reg.rax, 8, 0);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb34.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(400);
+ inst.args.push(arg);
+ bb34.append(inst);
+ bb35.successors.push(new FrequentedBlock(bb11, Normal));
+ bb35.successors.push(new FrequentedBlock(bb36, Normal));
+ bb35.predecessors.push(bb34);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb35.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb35.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(267);
+ inst.args.push(arg);
+ bb35.append(inst);
+ bb36.predecessors.push(bb35);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4374462160);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb36.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb36.append(inst);
+ return code;
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirpayloadjsairACLj8Cjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/payload-jsair-ACLj8C.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/payload-jsair-ACLj8C.js (rev 0)
+++ trunk/PerformanceTests/JSAir/payload-jsair-ACLj8C.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,1696 @@
</span><ins>+"use strict";
+// Generated by Air::dumpAsJS from #ACLj8C in JSAir
+function createPayloadJSAirACLj8C()
+{
+ let code = new Code();
+ let bb0 = code.addBlock();
+ let bb1 = code.addBlock();
+ let bb2 = code.addBlock();
+ let bb3 = code.addBlock();
+ let bb4 = code.addBlock();
+ let bb5 = code.addBlock();
+ let bb6 = code.addBlock();
+ let bb7 = code.addBlock();
+ let bb8 = code.addBlock();
+ let bb9 = code.addBlock();
+ let bb10 = code.addBlock();
+ let bb11 = code.addBlock();
+ let bb12 = code.addBlock();
+ let bb13 = code.addBlock();
+ let bb14 = code.addBlock();
+ let bb15 = code.addBlock();
+ let slot0 = code.addStackSlot(160, Locked);
+ let slot1 = code.addStackSlot(8, Spill);
+ let slot2 = code.addStackSlot(8, Spill);
+ let slot3 = code.addStackSlot(8, Spill);
+ let slot4 = code.addStackSlot(40, Locked);
+ let tmp61 = code.newTmp(GP);
+ let tmp60 = code.newTmp(GP);
+ let tmp59 = code.newTmp(GP);
+ let tmp58 = code.newTmp(GP);
+ let tmp57 = code.newTmp(GP);
+ let tmp56 = code.newTmp(GP);
+ let tmp55 = code.newTmp(GP);
+ let tmp54 = code.newTmp(GP);
+ let tmp53 = code.newTmp(GP);
+ let tmp52 = code.newTmp(GP);
+ let tmp51 = code.newTmp(GP);
+ let tmp50 = code.newTmp(GP);
+ let tmp49 = code.newTmp(GP);
+ let tmp48 = code.newTmp(GP);
+ let tmp47 = code.newTmp(GP);
+ let tmp46 = code.newTmp(GP);
+ let tmp45 = code.newTmp(GP);
+ let tmp44 = code.newTmp(GP);
+ let tmp43 = code.newTmp(GP);
+ let tmp42 = code.newTmp(GP);
+ let tmp41 = code.newTmp(GP);
+ let tmp40 = code.newTmp(GP);
+ let tmp39 = code.newTmp(GP);
+ let tmp38 = code.newTmp(GP);
+ let tmp37 = code.newTmp(GP);
+ let tmp36 = code.newTmp(GP);
+ let tmp35 = code.newTmp(GP);
+ let tmp34 = code.newTmp(GP);
+ let tmp33 = code.newTmp(GP);
+ let tmp32 = code.newTmp(GP);
+ let tmp31 = code.newTmp(GP);
+ let tmp30 = code.newTmp(GP);
+ let tmp29 = code.newTmp(GP);
+ let tmp28 = code.newTmp(GP);
+ let tmp27 = code.newTmp(GP);
+ let tmp26 = code.newTmp(GP);
+ let tmp25 = code.newTmp(GP);
+ let tmp24 = code.newTmp(GP);
+ let tmp23 = code.newTmp(GP);
+ let tmp22 = code.newTmp(GP);
+ let tmp21 = code.newTmp(GP);
+ let tmp20 = code.newTmp(GP);
+ let tmp19 = code.newTmp(GP);
+ let tmp18 = code.newTmp(GP);
+ let tmp17 = code.newTmp(GP);
+ let tmp16 = code.newTmp(GP);
+ let tmp15 = code.newTmp(GP);
+ let tmp14 = code.newTmp(GP);
+ let tmp13 = code.newTmp(GP);
+ let tmp12 = code.newTmp(GP);
+ let tmp11 = code.newTmp(GP);
+ let tmp10 = code.newTmp(GP);
+ let tmp9 = code.newTmp(GP);
+ let tmp8 = code.newTmp(GP);
+ let tmp7 = code.newTmp(GP);
+ let tmp6 = code.newTmp(GP);
+ let tmp5 = code.newTmp(GP);
+ let tmp4 = code.newTmp(GP);
+ let tmp3 = code.newTmp(GP);
+ let tmp2 = code.newTmp(GP);
+ let tmp1 = code.newTmp(GP);
+ let tmp0 = code.newTmp(GP);
+ let inst;
+ let arg;
+ bb0.successors.push(new FrequentedBlock(bb1, Normal));
+ bb0.successors.push(new FrequentedBlock(bb15, Normal));
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4346997392);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 16);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Scratch, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 72);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 64);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 56);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 48);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710654);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710656);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rcx, 32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rcx, 40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4346916592);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.r8, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(21);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.r12, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(364);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r12, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, -40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4346910400);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 72);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 64);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 56);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 48);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 40);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Xor64);
+ arg = Arg.createImm(6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot2, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot3, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ bb1.successors.push(new FrequentedBlock(bb3, Normal));
+ bb1.successors.push(new FrequentedBlock(bb2, Normal));
+ bb1.predecessors.push(bb0);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.r8, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(452);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb1.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r8, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb1.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4347313192);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb1.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb1.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb1.append(inst);
+ bb2.predecessors.push(bb1);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb2.append(inst);
+ inst = new Inst(Oops);
+ bb2.append(inst);
+ bb3.successors.push(new FrequentedBlock(bb4, Normal));
+ bb3.successors.push(new FrequentedBlock(bb7, Normal));
+ bb3.predecessors.push(bb1);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r8, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb3.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(23);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb3.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4346778864);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb3.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb3.append(inst);
+ bb4.successors.push(new FrequentedBlock(bb5, Normal));
+ bb4.successors.push(new FrequentedBlock(bb6, Normal));
+ bb4.predecessors.push(bb3);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 0);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 32);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 24);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 16);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 8);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4347218048);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4347218672);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb4.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Xor64);
+ arg = Arg.createImm(6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb4.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb4.append(inst);
+ bb5.successors.push(new FrequentedBlock(bb8, Normal));
+ bb5.predecessors.push(bb4);
+ inst = new Inst(Move);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateUse, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(406);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4346906176);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Jump);
+ bb5.append(inst);
+ bb6.successors.push(new FrequentedBlock(bb8, Normal));
+ bb6.predecessors.push(bb4);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Jump);
+ bb6.append(inst);
+ bb7.successors.push(new FrequentedBlock(bb12, Normal));
+ bb7.successors.push(new FrequentedBlock(bb9, Normal));
+ bb7.predecessors.push(bb3);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(5);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(40);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(48);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(56);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(40);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(48);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(56);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb7.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb7.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb7.append(inst);
+ bb8.successors.push(new FrequentedBlock(bb13, Normal));
+ bb8.successors.push(new FrequentedBlock(bb10, Normal));
+ bb8.predecessors.push(bb6);
+ bb8.predecessors.push(bb5);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb8.append(inst);
+ bb9.successors.push(new FrequentedBlock(bb11, Normal));
+ bb9.predecessors.push(bb7);
+ inst = new Inst(Jump);
+ bb9.append(inst);
+ bb10.successors.push(new FrequentedBlock(bb11, Normal));
+ bb10.predecessors.push(bb8);
+ inst = new Inst(Jump);
+ bb10.append(inst);
+ bb11.predecessors.push(bb9);
+ bb11.predecessors.push(bb10);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(Below);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(20);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb11.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb11.append(inst);
+ inst = new Inst(Oops);
+ bb11.append(inst);
+ bb12.successors.push(new FrequentedBlock(bb14, Normal));
+ bb12.predecessors.push(bb7);
+ inst = new Inst(Jump);
+ bb12.append(inst);
+ bb13.successors.push(new FrequentedBlock(bb14, Normal));
+ bb13.predecessors.push(bb8);
+ inst = new Inst(Jump);
+ bb13.append(inst);
+ bb14.predecessors.push(bb12);
+ bb14.predecessors.push(bb13);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(And64);
+ arg = Arg.createImm(-9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb14.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb14.append(inst);
+ bb15.predecessors.push(bb0);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ return code;
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirpayloadtypescriptscanIdentifierjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/payload-typescript-scanIdentifier.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/payload-typescript-scanIdentifier.js (rev 0)
+++ trunk/PerformanceTests/JSAir/payload-typescript-scanIdentifier.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,1847 @@
</span><ins>+"use strict";
+// Generated by Air::dumpAsJS from scanIdentifier#EPcFQe in Octane/typescript
+function createPayloadTypescriptScanIdentifier()
+{
+ let code = new Code();
+ let bb0 = code.addBlock();
+ let bb1 = code.addBlock();
+ let bb2 = code.addBlock();
+ let bb3 = code.addBlock();
+ let bb4 = code.addBlock();
+ let bb5 = code.addBlock();
+ let bb6 = code.addBlock();
+ let bb7 = code.addBlock();
+ let bb8 = code.addBlock();
+ let bb9 = code.addBlock();
+ let bb10 = code.addBlock();
+ let bb11 = code.addBlock();
+ let bb12 = code.addBlock();
+ let bb13 = code.addBlock();
+ let bb14 = code.addBlock();
+ let bb15 = code.addBlock();
+ let bb16 = code.addBlock();
+ let bb17 = code.addBlock();
+ let bb18 = code.addBlock();
+ let bb19 = code.addBlock();
+ let bb20 = code.addBlock();
+ let bb21 = code.addBlock();
+ let bb22 = code.addBlock();
+ let bb23 = code.addBlock();
+ let bb24 = code.addBlock();
+ let bb25 = code.addBlock();
+ let bb26 = code.addBlock();
+ let bb27 = code.addBlock();
+ let bb28 = code.addBlock();
+ let bb29 = code.addBlock();
+ let bb30 = code.addBlock();
+ let bb31 = code.addBlock();
+ let bb32 = code.addBlock();
+ let bb33 = code.addBlock();
+ let bb34 = code.addBlock();
+ let slot0 = code.addStackSlot(56, Locked);
+ let slot1 = code.addStackSlot(8, Spill);
+ let slot2 = code.addStackSlot(8, Spill);
+ let slot3 = code.addStackSlot(8, Spill);
+ let slot4 = code.addStackSlot(8, Spill);
+ let slot5 = code.addStackSlot(4, Spill);
+ let slot6 = code.addStackSlot(8, Spill);
+ let slot7 = code.addStackSlot(8, Spill);
+ let slot8 = code.addStackSlot(8, Spill);
+ let slot9 = code.addStackSlot(40, Locked);
+ let tmp98 = code.newTmp(GP);
+ let tmp97 = code.newTmp(GP);
+ let tmp96 = code.newTmp(GP);
+ let tmp95 = code.newTmp(GP);
+ let tmp94 = code.newTmp(GP);
+ let tmp93 = code.newTmp(GP);
+ let tmp92 = code.newTmp(GP);
+ let tmp91 = code.newTmp(GP);
+ let tmp90 = code.newTmp(GP);
+ let tmp89 = code.newTmp(GP);
+ let tmp88 = code.newTmp(GP);
+ let tmp87 = code.newTmp(GP);
+ let tmp86 = code.newTmp(GP);
+ let tmp85 = code.newTmp(GP);
+ let tmp84 = code.newTmp(GP);
+ let tmp83 = code.newTmp(GP);
+ let tmp82 = code.newTmp(GP);
+ let tmp81 = code.newTmp(GP);
+ let tmp80 = code.newTmp(GP);
+ let tmp79 = code.newTmp(GP);
+ let tmp78 = code.newTmp(GP);
+ let tmp77 = code.newTmp(GP);
+ let tmp76 = code.newTmp(GP);
+ let tmp75 = code.newTmp(GP);
+ let tmp74 = code.newTmp(GP);
+ let tmp73 = code.newTmp(GP);
+ let tmp72 = code.newTmp(GP);
+ let tmp71 = code.newTmp(GP);
+ let tmp70 = code.newTmp(GP);
+ let tmp69 = code.newTmp(GP);
+ let tmp68 = code.newTmp(GP);
+ let tmp67 = code.newTmp(GP);
+ let tmp66 = code.newTmp(GP);
+ let tmp65 = code.newTmp(GP);
+ let tmp64 = code.newTmp(GP);
+ let tmp63 = code.newTmp(GP);
+ let tmp62 = code.newTmp(GP);
+ let tmp61 = code.newTmp(GP);
+ let tmp60 = code.newTmp(GP);
+ let tmp59 = code.newTmp(GP);
+ let tmp58 = code.newTmp(GP);
+ let tmp57 = code.newTmp(GP);
+ let tmp56 = code.newTmp(GP);
+ let tmp55 = code.newTmp(GP);
+ let tmp54 = code.newTmp(GP);
+ let tmp53 = code.newTmp(GP);
+ let tmp52 = code.newTmp(GP);
+ let tmp51 = code.newTmp(GP);
+ let tmp50 = code.newTmp(GP);
+ let tmp49 = code.newTmp(GP);
+ let tmp48 = code.newTmp(GP);
+ let tmp47 = code.newTmp(GP);
+ let tmp46 = code.newTmp(GP);
+ let tmp45 = code.newTmp(GP);
+ let tmp44 = code.newTmp(GP);
+ let tmp43 = code.newTmp(GP);
+ let tmp42 = code.newTmp(GP);
+ let tmp41 = code.newTmp(GP);
+ let tmp40 = code.newTmp(GP);
+ let tmp39 = code.newTmp(GP);
+ let tmp38 = code.newTmp(GP);
+ let tmp37 = code.newTmp(GP);
+ let tmp36 = code.newTmp(GP);
+ let tmp35 = code.newTmp(GP);
+ let tmp34 = code.newTmp(GP);
+ let tmp33 = code.newTmp(GP);
+ let tmp32 = code.newTmp(GP);
+ let tmp31 = code.newTmp(GP);
+ let tmp30 = code.newTmp(GP);
+ let tmp29 = code.newTmp(GP);
+ let tmp28 = code.newTmp(GP);
+ let tmp27 = code.newTmp(GP);
+ let tmp26 = code.newTmp(GP);
+ let tmp25 = code.newTmp(GP);
+ let tmp24 = code.newTmp(GP);
+ let tmp23 = code.newTmp(GP);
+ let tmp22 = code.newTmp(GP);
+ let tmp21 = code.newTmp(GP);
+ let tmp20 = code.newTmp(GP);
+ let tmp19 = code.newTmp(GP);
+ let tmp18 = code.newTmp(GP);
+ let tmp17 = code.newTmp(GP);
+ let tmp16 = code.newTmp(GP);
+ let tmp15 = code.newTmp(GP);
+ let tmp14 = code.newTmp(GP);
+ let tmp13 = code.newTmp(GP);
+ let tmp12 = code.newTmp(GP);
+ let tmp11 = code.newTmp(GP);
+ let tmp10 = code.newTmp(GP);
+ let tmp9 = code.newTmp(GP);
+ let tmp8 = code.newTmp(GP);
+ let tmp7 = code.newTmp(GP);
+ let tmp6 = code.newTmp(GP);
+ let tmp5 = code.newTmp(GP);
+ let tmp4 = code.newTmp(GP);
+ let tmp3 = code.newTmp(GP);
+ let tmp2 = code.newTmp(GP);
+ let tmp1 = code.newTmp(GP);
+ let tmp0 = code.newTmp(GP);
+ let inst;
+ let arg;
+ bb0.successors.push(new FrequentedBlock(bb5, Normal));
+ bb0.successors.push(new FrequentedBlock(bb4, Normal));
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4579251936);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 16);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Scratch, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbp, 40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710654);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 5);
+ inst.args.push(arg);
+ arg = Arg.createImm(21);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 8});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(2540);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 72);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Compare32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(92);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4556913984);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(NotEqual);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(80);
+ inst.args.push(arg);
+ arg = Arg.createBigImm(4556913984);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4556913992);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createAddr(Reg.r12, -8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb0.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createIndex(Reg.r12, Reg.rax, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(MoveConditionallyTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Xor64);
+ arg = Arg.createImm(6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-2);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot2, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot1, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4531909360);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot4, 0);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4510266960);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(-281474976710656);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb0.append(inst);
+ bb1.predecessors.push(bb6);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb1.append(inst);
+ inst = new Inst(Oops);
+ bb1.append(inst);
+ bb2.predecessors.push(bb23);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb2.append(inst);
+ inst = new Inst(Oops);
+ bb2.append(inst);
+ bb3.predecessors.push(bb32);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb3.append(inst);
+ inst = new Inst(Oops);
+ bb3.append(inst);
+ bb4.predecessors.push(bb0);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb4.append(inst);
+ inst = new Inst(Oops);
+ bb4.append(inst);
+ bb5.successors.push(new FrequentedBlock(bb8, Normal));
+ bb5.successors.push(new FrequentedBlock(bb6, Rare));
+ bb5.predecessors.push(bb0);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 56);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, -24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r10, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb5.append(inst);
+ bb6.successors.push(new FrequentedBlock(bb1, Rare));
+ bb6.successors.push(new FrequentedBlock(bb7, Normal));
+ bb6.predecessors.push(bb5);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 36);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot8, 0);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot7, 0);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot6, 0);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createStack(slot8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createStack(slot7, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createStack(slot6, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4531909360);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb6.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ bb6.append(inst);
+ bb7.successors.push(new FrequentedBlock(bb11, Normal));
+ bb7.predecessors.push(bb6);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb7.append(inst);
+ inst = new Inst(Jump);
+ bb7.append(inst);
+ bb8.successors.push(new FrequentedBlock(bb11, Normal));
+ bb8.predecessors.push(bb5);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb8.append(inst);
+ inst = new Inst(Jump);
+ bb8.append(inst);
+ bb9.successors.push(new FrequentedBlock(bb11, Normal));
+ bb9.predecessors.push(bb15);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb9.append(inst);
+ inst = new Inst(Jump);
+ bb9.append(inst);
+ bb10.successors.push(new FrequentedBlock(bb11, Normal));
+ bb10.predecessors.push(bb18);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb10.append(inst);
+ inst = new Inst(Jump);
+ bb10.append(inst);
+ bb11.successors.push(new FrequentedBlock(bb12, Normal));
+ bb11.successors.push(new FrequentedBlock(bb16, Normal));
+ bb11.predecessors.push(bb7);
+ bb11.predecessors.push(bb10);
+ bb11.predecessors.push(bb9);
+ bb11.predecessors.push(bb8);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r9);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb11.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 40);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 32);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(Overflow);
+ inst.args.push(arg);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});
+ bb11.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 32);
+ inst.args.push(arg);
+ bb11.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThan);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb11.append(inst);
+ bb12.successors.push(new FrequentedBlock(bb13, Normal));
+ bb12.successors.push(new FrequentedBlock(bb14, Normal));
+ bb12.predecessors.push(bb11);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.r10, 12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb12.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r10, 16);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb12.append(inst);
+ inst = new Inst(BranchTest32);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rax, 16);
+ inst.args.push(arg);
+ arg = Arg.createImm(8);
+ inst.args.push(arg);
+ bb12.append(inst);
+ bb13.successors.push(new FrequentedBlock(bb15, Normal));
+ bb13.predecessors.push(bb12);
+ inst = new Inst(Load8);
+ arg = Arg.createIndex(Reg.r9, Reg.rdx, 1, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb13.append(inst);
+ inst = new Inst(Jump);
+ bb13.append(inst);
+ bb14.successors.push(new FrequentedBlock(bb15, Normal));
+ bb14.predecessors.push(bb12);
+ inst = new Inst(Load16);
+ arg = Arg.createIndex(Reg.r9, Reg.rdx, 2, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb14.append(inst);
+ inst = new Inst(Jump);
+ bb14.append(inst);
+ bb15.successors.push(new FrequentedBlock(bb9, Normal));
+ bb15.successors.push(new FrequentedBlock(bb17, Normal));
+ bb15.predecessors.push(bb14);
+ bb15.predecessors.push(bb13);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Add64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbx, 72);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createRelCond(AboveOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r8);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb15.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createIndex(Reg.r12, Reg.rax, 8, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(MoveConditionallyTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Xor64);
+ arg = Arg.createImm(6);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(-2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb15.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(1);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb15.append(inst);
+ bb16.predecessors.push(bb11);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb16.append(inst);
+ inst = new Inst(Oops);
+ bb16.append(inst);
+ bb17.successors.push(new FrequentedBlock(bb18, Normal));
+ bb17.successors.push(new FrequentedBlock(bb19, Normal));
+ bb17.predecessors.push(bb15);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(48);
+ inst.args.push(arg);
+ bb17.append(inst);
+ bb18.successors.push(new FrequentedBlock(bb10, Normal));
+ bb18.successors.push(new FrequentedBlock(bb19, Normal));
+ bb18.predecessors.push(bb17);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(LessThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(57);
+ inst.args.push(arg);
+ bb18.append(inst);
+ bb19.successors.push(new FrequentedBlock(bb20, Normal));
+ bb19.successors.push(new FrequentedBlock(bb21, Normal));
+ bb19.predecessors.push(bb17);
+ bb19.predecessors.push(bb18);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(GreaterThanOrEqual);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(128);
+ inst.args.push(arg);
+ bb19.append(inst);
+ bb20.predecessors.push(bb19);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb20.append(inst);
+ inst = new Inst(Oops);
+ bb20.append(inst);
+ bb21.successors.push(new FrequentedBlock(bb22, Normal));
+ bb21.successors.push(new FrequentedBlock(bb23, Normal));
+ bb21.predecessors.push(bb19);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ bb21.append(inst);
+ inst = new Inst(Branch32);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createImm(92);
+ inst.args.push(arg);
+ bb21.append(inst);
+ bb22.predecessors.push(bb21);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot5, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb22.append(inst);
+ inst = new Inst(Oops);
+ bb22.append(inst);
+ bb23.successors.push(new FrequentedBlock(bb2, Rare));
+ bb23.successors.push(new FrequentedBlock(bb24, Normal));
+ bb23.predecessors.push(bb21);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rbx, 48);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4556943616);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(3);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r10);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r11);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(40);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4556963336);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, 0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.rax, -1336);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createAddr(Reg.r13, 24);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot0, 0);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 36);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4510204912);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createStack(slot3, 0);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb23.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4531909360);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb23.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ bb23.append(inst);
+ bb24.successors.push(new FrequentedBlock(bb25, Normal));
+ bb24.successors.push(new FrequentedBlock(bb26, Normal));
+ bb24.predecessors.push(bb23);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r13);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb24.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb24.append(inst);
+ bb25.successors.push(new FrequentedBlock(bb27, Normal));
+ bb25.successors.push(new FrequentedBlock(bb26, Normal));
+ bb25.predecessors.push(bb24);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb25.append(inst);
+ inst = new Inst(And64);
+ arg = Arg.createImm(-9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb25.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ bb25.append(inst);
+ bb26.successors.push(new FrequentedBlock(bb29, Normal));
+ bb26.successors.push(new FrequentedBlock(bb28, Normal));
+ bb26.predecessors.push(bb24);
+ bb26.predecessors.push(bb25);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ bb26.append(inst);
+ bb27.successors.push(new FrequentedBlock(bb30, Normal));
+ bb27.predecessors.push(bb25);
+ inst = new Inst(Move);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb27.append(inst);
+ inst = new Inst(Jump);
+ bb27.append(inst);
+ bb28.successors.push(new FrequentedBlock(bb32, Normal));
+ bb28.predecessors.push(bb26);
+ inst = new Inst(Jump);
+ bb28.append(inst);
+ bb29.successors.push(new FrequentedBlock(bb30, Normal));
+ bb29.predecessors.push(bb26);
+ inst = new Inst(Jump);
+ bb29.append(inst);
+ bb30.successors.push(new FrequentedBlock(bb34, Normal));
+ bb30.successors.push(new FrequentedBlock(bb31, Normal));
+ bb30.predecessors.push(bb29);
+ bb30.predecessors.push(bb27);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb30.append(inst);
+ inst = new Inst(And64);
+ arg = Arg.createImm(-9);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb30.append(inst);
+ inst = new Inst(Branch64);
+ arg = Arg.createRelCond(Equal);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createImm(2);
+ inst.args.push(arg);
+ bb30.append(inst);
+ bb31.successors.push(new FrequentedBlock(bb32, Normal));
+ bb31.predecessors.push(bb30);
+ inst = new Inst(Jump);
+ bb31.append(inst);
+ bb32.successors.push(new FrequentedBlock(bb3, Rare));
+ bb32.successors.push(new FrequentedBlock(bb33, Normal));
+ bb32.predecessors.push(bb28);
+ bb32.predecessors.push(bb31);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(3);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rbp, 36);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4556913680);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rbp);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createBigImm(4510204912);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.xmm0);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rsi);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rdx);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: FP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb32.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4531909360);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rcx);
+ inst.args.push(arg);
+ bb32.append(inst);
+ inst = new Inst(BranchTest64);
+ arg = Arg.createResCond(NonZero);
+ inst.args.push(arg);
+ arg = Arg.createAddr(Reg.rcx, 0);
+ inst.args.push(arg);
+ arg = Arg.createImm(-1);
+ inst.args.push(arg);
+ bb32.append(inst);
+ bb33.predecessors.push(bb32);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb33.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb33.append(inst);
+ bb34.predecessors.push(bb30);
+ inst = new Inst(Move);
+ arg = Arg.createBigImm(4555757344);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move32);
+ arg = Arg.createImm(3);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createTmp(Reg.r12);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Move);
+ arg = Arg.createImm(6);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(40);
+ inst.args.push(arg);
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(8);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(16);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(24);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(32);
+ inst.args.push(arg);
+ arg = Arg.createCallArg(40);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r15);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.r14);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.extraEarlyClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.rcx);
+ inst.extraClobberedRegs.add(Reg.rdx);
+ inst.extraClobberedRegs.add(Reg.rsi);
+ inst.extraClobberedRegs.add(Reg.rdi);
+ inst.extraClobberedRegs.add(Reg.r8);
+ inst.extraClobberedRegs.add(Reg.r9);
+ inst.extraClobberedRegs.add(Reg.r10);
+ inst.extraClobberedRegs.add(Reg.r11);
+ inst.extraClobberedRegs.add(Reg.xmm0);
+ inst.extraClobberedRegs.add(Reg.xmm1);
+ inst.extraClobberedRegs.add(Reg.xmm2);
+ inst.extraClobberedRegs.add(Reg.xmm3);
+ inst.extraClobberedRegs.add(Reg.xmm4);
+ inst.extraClobberedRegs.add(Reg.xmm5);
+ inst.extraClobberedRegs.add(Reg.xmm6);
+ inst.extraClobberedRegs.add(Reg.xmm7);
+ inst.extraClobberedRegs.add(Reg.xmm8);
+ inst.extraClobberedRegs.add(Reg.xmm9);
+ inst.extraClobberedRegs.add(Reg.xmm10);
+ inst.extraClobberedRegs.add(Reg.xmm11);
+ inst.extraClobberedRegs.add(Reg.xmm12);
+ inst.extraClobberedRegs.add(Reg.xmm13);
+ inst.extraClobberedRegs.add(Reg.xmm14);
+ inst.extraClobberedRegs.add(Reg.xmm15);
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Def, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(Patch);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rbx);
+ inst.args.push(arg);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ inst.patchHasNonArgEffects = true;
+ inst.extraEarlyClobberedRegs = new Set();
+ inst.extraClobberedRegs = new Set();
+ inst.patchArgData = [];
+ inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});
+ bb34.append(inst);
+ inst = new Inst(Ret64);
+ arg = Arg.createTmp(Reg.rax);
+ inst.args.push(arg);
+ bb34.append(inst);
+ return code;
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirregjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/reg.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/reg.js (rev 0)
+++ trunk/PerformanceTests/JSAir/reg.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,133 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Reg extends TmpBase {
+ constructor(index, type, name, isCalleeSave)
+ {
+ super();
+ this._index = index;
+ this._type = type;
+ this._name = name;
+ this._isCalleeSave = !!isCalleeSave;
+ }
+
+ static fromReg(reg)
+ {
+ return reg;
+ }
+
+ get index() { return this._index; }
+ get type() { return this._type; }
+ get name() { return this._name; }
+ get isCalleeSave() { return this._isCalleeSave; }
+
+ get isReg() { return true; }
+
+ toString()
+ {
+ return "%" + this._name;
+ }
+
+ static extract(arg)
+ {
+ if (arg.isReg)
+ return arg.reg;
+ return null;
+ }
+
+ static forEachFast(arg, func)
+ {
+ return arg.forEachTmpFast(tmp => {
+ if (!tmp.isReg)
+ return;
+ return func(tmp);
+ });
+ }
+
+ static forEach(arg, argRole, argType, argWidth, func)
+ {
+ return arg.forEachTmp(
+ argRole, argType, argWidth,
+ (tmp, role, type, width) => {
+ if (!tmp.isReg)
+ return;
+ return func(tmp, role, type, width);
+ });
+ }
+}
+
+{
+ Reg.regs = [];
+ function newReg(...args)
+ {
+ let result = new Reg(...args);
+ Reg.regs.push(result);
+ return result;
+ }
+
+ // Define X86_64 GPRs
+ {
+ let index = 0;
+ function newGPR(name, isCalleeSave) { return newReg(index++, GP, name, isCalleeSave); }
+
+ Reg.rax = newGPR("rax");
+ Reg.rcx = newGPR("rcx");
+ Reg.rdx = newGPR("rdx");
+ Reg.rbx = newGPR("rbx", true);
+ Reg.rsp = newGPR("rsp");
+ Reg.rbp = newGPR("rbp", true);
+ Reg.rsi = newGPR("rsi");
+ Reg.rdi = newGPR("rdi");
+ for (let i = 8; i <= 15; ++i)
+ Reg["r" + i] = newGPR("r" + i, i >= 12);
+ }
+
+ // Define X86_64 FPRs.
+ for (let i = 0; i <= 15; ++i)
+ Reg["xmm" + i] = newReg(i, FP, "xmm" + i);
+
+ Reg.gprs = []
+ Reg.fprs = []
+ Reg.calleeSaveGPRs = []
+ Reg.calleeSaveFPRs = []
+ Reg.calleeSaves = []
+ for (let reg of Reg.regs) {
+ if (reg.isGP) {
+ Reg.gprs.push(reg);
+ if (reg.isCalleeSave)
+ Reg.calleeSaveGPRs.push(reg);
+ } else {
+ Reg.fprs.push(reg);
+ if (reg.isCalleeSave)
+ Reg.calleeSaveFPRS.push(reg);
+ }
+ if (reg.isCalleeSave)
+ Reg.calleeSaves.push(reg);
+ }
+
+ Reg.callFrameRegister = Reg.rbp;
+ Reg.stackPointerRegister = Reg.rsp;
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirstack_slotjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/stack_slot.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/stack_slot.js (rev 0)
+++ trunk/PerformanceTests/JSAir/stack_slot.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,97 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class StackSlot {
+ constructor(index, byteSize, kind)
+ {
+ this._index = index;
+ this._byteSize = byteSize;
+ this._kind = kind;
+ }
+
+ get byteSize() { return this._byteSize; }
+ get kind() { return this._kind; }
+
+ get isLocked() { return this._kind == Locked; }
+ get isSpill() { return this._kind == Spill; }
+
+ get index() { return this._index; }
+
+ ensureSize(size)
+ {
+ if (this._offsetFromFP)
+ throw new Error("Stack slot already allocated");
+ this._byteSize = Math.max(this._byteSize, size);
+ }
+
+ get alignment()
+ {
+ if (this._byteSize <= 1)
+ return 1;
+ if (this._byteSize <= 2)
+ return 2;
+ if (this._byteSize <= 4)
+ return 4;
+ return 8;
+ }
+
+ get offsetFromFP() { return this._offsetFromFP; }
+
+ setOffsetFromFP(value) { this._offsetFromFP = value; }
+
+ toString()
+ {
+ return "" + (this.isSpill ? "spill" : "stack") + this._index + "<" + this._byteSize +
+ (this._offsetFromFP ? ", offset = " + this._offsetFromFP : "") + ">";
+ }
+
+ static extract(arg)
+ {
+ if (arg.isStack)
+ return arg.stackSlot;
+ return null;
+ }
+
+ static forEachFast(arg, func)
+ {
+ if (!arg.isStack)
+ return;
+
+ let replacement;
+ if (replacement = func(arg.stackSlot))
+ return Arg.createStack(replacement, this._offset);
+ }
+
+ static forEach(arg, role, type, width, func)
+ {
+ if (!arg.isStack)
+ return;
+
+ let replacement;
+ if (replacement = func(arg.stackSlot, role, type, width))
+ return Arg.createStack(replacement, this._offset);
+ }
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirsymbolsjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/symbols.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/symbols.js (rev 0)
+++ trunk/PerformanceTests/JSAir/symbols.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,82 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+// This file is for misc symbols.
+
+// B3 types
+const Void = Symbol("Void");
+const Int32 = Symbol("Int32");
+const Int64 = Symbol("Int64");
+const Float = Symbol("Float");
+const Double = Symbol("Double");
+
+// Arg type
+const GP = Symbol("GP");
+const FP = Symbol("FP");
+
+// Stack slot kind
+const Locked = Symbol("Locked");
+const Spill = Symbol("Spill");
+
+// Frequency class
+const Normal = Symbol("Normal");
+const Rare = Symbol("Rare");
+
+// Relational conditions
+const Equal = Symbol("Equal");
+const NotEqual = Symbol("NotEqual");
+const Above = Symbol("Above");
+const AboveOrEqual = Symbol("AboveOrEqual");
+const Below = Symbol("Below");
+const BelowOrEqual = Symbol("BelowOrEqual");
+const GreaterThan = Symbol("GreaterThan");
+const GreaterThanOrEqual = Symbol("GreaterThanOrEqual");
+const LessThan = Symbol("LessThan");
+const LessThanOrEqual = Symbol("LessThanOrEqual");
+
+// Result conditions
+const Overflow = Symbol("Overflow");
+const Signed = Symbol("Signed");
+const PositiveOrZero = Symbol("PositiveOrZero");
+const Zero = Symbol("Zero");
+const NonZero = Symbol("NonZero");
+
+// Double conditions
+const DoubleEqual = Symbol("DoubleEqual");
+const DoubleNotEqual = Symbol("DoubleNotEqual");
+const DoubleGreaterThan = Symbol("DoubleGreaterThan");
+const DoubleGreaterThanOrEqual = Symbol("DoubleGreaterThanOrEqual");
+const DoubleLessThan = Symbol("DoubleLessThan");
+const DoubleLessThanOrEqual = Symbol("DoubleLessThanOrEqual");
+const DoubleEqualOrUnordered = Symbol("DoubleEqualOrUnordered");
+const DoubleNotEqualOrUnordered = Symbol("DoubleNotEqualOrUnordered");
+const DoubleGreaterThanOrUnordered = Symbol("DoubleGreaterThanOrUnordered");
+const DoubleGreaterThanOrEqualOrUnordered = Symbol("DoubleGreaterThanOrEqualOrUnordered");
+const DoubleLessThanOrUnordered = Symbol("DoubleLessThanOrUnordered");
+const DoubleLessThanOrEqualOrUnordered = Symbol("DoubleLessThanOrEqualOrUnordered");
+
+// Define pointerType()
+const Ptr = 64;
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirtesthtml"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/test.html (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/test.html (rev 0)
+++ trunk/PerformanceTests/JSAir/test.html 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,41 @@
</span><ins>+<html>
+<head>
+<title>JSAir</title>
+<script src="symbols.js"></script>
+<script src="tmp_base.js"></script>
+<script src="arg.js"></script>
+<script src="basic_block.js"></script>
+<script src="code.js"></script>
+<script src="frequented_block.js"></script>
+<script src="inst.js"></script>
+<script src="opcode.js"></script>
+<script src="reg.js"></script>
+<script src="stack_slot.js"></script>
+<script src="tmp.js"></script>
+<script src="util.js"></script>
+<script src="custom.js"></script>
+<script src="liveness.js"></script>
+<script src="insertion_set.js"></script>
+<script src="allocate_stack.js"></script>
+<script src="payload-gbemu-executeIteration.js"></script>
+<script src="payload-imaging-gaussian-blur-gaussianBlur.js"></script>
+<script src="payload-jsair-ACLj8C.js"></script>
+<script src="payload-typescript-scanIdentifier.js"></script>
+<script src="benchmark.js"></script>
+<script>
+ function runTest() {
+ var result = benchmark();
+ document.getElementById("result-summary").innerHTML = "That took " + result + " ms.";
+ }
+</script>
+</head>
+<body>
+<h1>JSAir</h1>
+<p>
+ <div id="result-summary"></div>
+ <div><a href="javascript:runTest()">Start Test</a></div>
+</p>
+</body>
+</html>
+
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirtestjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/test.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/test.js (rev 0)
+++ trunk/PerformanceTests/JSAir/test.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,11 @@
</span><ins>+"use strict";
+
+load("all.js");
+load("payload-gbemu-executeIteration.js");
+load("payload-imaging-gaussian-blur-gaussianBlur.js");
+load("payload-jsair-ACLj8C.js");
+load("payload-typescript-scanIdentifier.js");
+load("benchmark.js");
+
+let result = benchmark();
+print("That took " + result + " ms.");
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirtmpjs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/tmp.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/tmp.js (rev 0)
+++ trunk/PerformanceTests/JSAir/tmp.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,59 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class Tmp extends TmpBase {
+ constructor(index, type)
+ {
+ super();
+ this._index = index;
+ this._type = type;
+ }
+
+ static fromReg(reg)
+ {
+ return reg;
+ }
+
+ get index() { return this._index; }
+ get type() { return this._type; }
+
+ get isReg() { return false; }
+
+ toString()
+ {
+ return "%" + (this.isGP ? "" : "f") + "tmp" + this._index;
+ }
+
+ static extract(arg)
+ {
+ if (arg.isTmp)
+ return arg.tmp;
+ return null;
+ }
+
+ static forEachFast(arg, func) { return arg.forEachTmpFast(func); }
+ static forEach(arg, role, type, width, func) { return arg.forEachTmp(role, type, width, func); }
+}
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirtmp_basejs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/tmp_base.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/tmp_base.js (rev 0)
+++ trunk/PerformanceTests/JSAir/tmp_base.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,55 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+class TmpBase {
+ get isGP() { return this.type == GP; }
+ get isFP() { return this.type == FP; }
+
+ get isGPR() { return this.isReg && this.isGP; }
+ get isFPR() { return this.isReg && this.isFP; }
+
+ get reg()
+ {
+ if (!this.isReg)
+ throw new Error("Called .reg on non-Reg");
+ return this;
+ }
+
+ get gpr()
+ {
+ if (!this.isGPR)
+ throw new Error("Called .gpr on non-GPR");
+ return this;
+ }
+
+ get fpr()
+ {
+ if (!this.isFPR)
+ throw new Error("Called .fpr on non-FPR");
+ return this;
+ }
+}
+
</ins></span></pre></div>
<a id="trunkPerformanceTestsJSAirutiljs"></a>
<div class="addfile"><h4>Added: trunk/PerformanceTests/JSAir/util.js (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/PerformanceTests/JSAir/util.js (rev 0)
+++ trunk/PerformanceTests/JSAir/util.js 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,174 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+function isRepresentableAsInt32(value)
+{
+ return (value | 0) === value;
+}
+
+function addIndexed(list, cons, ...args)
+{
+ let result = new cons(list.length, ...args);
+ list.push(result);
+ return result;
+}
+
+const stackAlignmentBytes = 16;
+
+function roundUpToMultipleOf(amount, value)
+{
+ return Math.ceil(value / amount * amount);
+}
+
+function symbolName(symbol)
+{
+ let fullString = symbol.toString();
+ return fullString.substring("Symbol(".length, fullString.length - ")".length);
+}
+
+function setToString(set)
+{
+ let result = "";
+ for (let value of set) {
+ if (result)
+ result += ", ";
+ result += value;
+ }
+ return result;
+}
+
+function mergeIntoSet(target, source)
+{
+ let didAdd = false;
+ for (let value of source) {
+ if (target.has(value))
+ continue;
+ target.add(value);
+ didAdd = true;
+ }
+ return didAdd;
+}
+
+function nonEmptyRangesOverlap(leftMin, leftMax, rightMin, rightMax)
+{
+ if (leftMin >= leftMax)
+ throw new Error("Bad left range");
+ if (rightMin >= rightMax)
+ throw new Error("Bad right range");
+
+ if (leftMin <= rightMin && leftMax > rightMin)
+ return true;
+ if (rightMin <= leftMin && rightMax > leftMin)
+ return true;
+ return false;
+}
+
+function rangesOverlap(leftMin, leftMax, rightMin, rightMax)
+{
+ if (leftMin > leftMax)
+ throw new Error("Bad left range");
+ if (rightMin > rightMax)
+ throw new Error("Bad right range");
+
+ if (leftMin == leftMax)
+ return false;
+ if (rightMin == rightMax)
+ return false;
+
+ return nonEmptyRangesOverlap(leftMin, leftMax, rightMin, rightMax);
+}
+
+function removeAllMatching(array, func)
+{
+ let srcIndex = 0;
+ let dstIndex = 0;
+ while (srcIndex < array.length) {
+ let value = array[srcIndex++];
+ if (!func(value))
+ array[dstIndex++] = value;
+ }
+ array.length = dstIndex;
+}
+
+function bubbleSort(array, lessThan)
+{
+ function swap(i, j)
+ {
+ var tmp = array[i];
+ array[i] = array[j];
+ array[j] = tmp;
+ }
+
+ let begin = 0;
+ let end = array.length;
+ for (;;) {
+ let changed = false;
+
+ function bubble(i, j)
+ {
+ if (lessThan(array[i], array[j])) {
+ swap(i, j);
+ changed = true;
+ }
+ }
+
+ if (end < begin)
+ throw new Error("Begin and end are messed up");
+
+ let limit = end - begin;
+ for (let i = limit; i-- > 1;)
+ bubble(begin + i, begin + i - 1);
+ if (!changed)
+ return;
+
+ // After one run, the first element in the list is guaranteed to be the smallest.
+ begin++;
+
+ // Now go in the other direction. This eliminates most sorting pathologies.
+ changed = false;
+
+ if (end < begin)
+ throw new Error("Begin and end are messed up");
+
+ limit = end - begin;
+ for (let i = 1; i < limit; ++i)
+ bubble(begin + i, begin + i - 1);
+ if (!changed)
+ return;
+
+ // Now the last element is guaranteed to be the largest.
+ end--;
+ }
+}
+
+let currentTime;
+if (this.performance && performance.now)
+ currentTime = function() { return performance.now() };
+else if (this.preciseTime)
+ currentTime = function() { return preciseTime() * 1000; };
+else
+ currentTime = function() { return +new Date(); };
+
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCoreCMakeListstxt"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/CMakeLists.txt (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/CMakeLists.txt 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/CMakeLists.txt 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -76,6 +76,7 @@
</span><span class="cx"> b3/air/AirCCallingConvention.cpp
</span><span class="cx"> b3/air/AirCode.cpp
</span><span class="cx"> b3/air/AirCustom.cpp
</span><ins>+ b3/air/AirDumpAsJS.cpp
</ins><span class="cx"> b3/air/AirEliminateDeadCode.cpp
</span><span class="cx"> b3/air/AirEmitShuffle.cpp
</span><span class="cx"> b3/air/AirFixObviousSpills.cpp
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1,3 +1,56 @@
</span><ins>+2016-06-07 Filip Pizlo <fpizlo@apple.com>
+
+ Implement Air::allocateStack() in ES6 to see how much of a bad idea that is
+ https://bugs.webkit.org/show_bug.cgi?id=158318
+
+ Reviewed by Saam Barati.
+
+ Most of these changes are to support dumpAsJS(). But I also found some duplicate and dead
+ code while rewriting it to JS.
+
+ * CMakeLists.txt:
+ * JavaScriptCore.xcodeproj/project.pbxproj:
+ * b3/air/AirAllocateStack.cpp:
+ * b3/air/AirArg.h:
+ (JSC::B3::Air::Arg::isSomeImm):
+ (JSC::B3::Air::Arg::isAddr):
+ (JSC::B3::Air::Arg::tmpIndex):
+ (JSC::B3::Air::Arg::isValidImmForm):
+ (JSC::B3::Air::Arg::withOffset): Deleted. This was dead code.
+ * b3/air/AirArgInlines.h: It turns out that Inst has a ForEach thing that duplicated some of the logic of ArgThingHelper, so I just made ArgThingHelper more powerful.
+ (JSC::B3::Air::ArgThingHelper<Arg>::forEach):
+ (JSC::B3::Air::ArgThingHelper<Reg>::is):
+ (JSC::B3::Air::ArgThingHelper<Reg>::as):
+ (JSC::B3::Air::ArgThingHelper<Reg>::forEachFast):
+ (JSC::B3::Air::ArgThingHelper<Reg>::forEach):
+ (JSC::B3::Air::Arg::is):
+ * b3/air/AirDumpAsJS.cpp: Added.
+ (JSC::B3::Air::dumpAsJS):
+ * b3/air/AirDumpAsJS.h: Added.
+ * b3/air/AirFixObviousSpills.cpp:
+ * b3/air/AirGenerate.cpp:
+ (JSC::B3::Air::prepareForGeneration):
+ * b3/air/AirInstInlines.h:
+ (JSC::B3::Air::Inst::forEach):
+ (JSC::B3::Air::Inst::extraClobberedRegs):
+ (JSC::B3::Air::ForEach<Tmp>::forEach): Deleted. This was doing what ArgThingHelper would have done but not as well.
+ (JSC::B3::Air::ForEach<Arg>::forEach): Deleted.
+ (JSC::B3::Air::ForEach<Reg>::forEach): Deleted.
+ * b3/air/AirLogRegisterPressure.cpp:
+ * b3/air/AirReportUsedRegisters.cpp:
+ * b3/air/AirSpillEverything.cpp:
+ * b3/air/opcode_generator.rb: Make this dump opcode.js, which is like what it dumps for C++.
+ * jit/Reg.cpp:
+ (JSC::Reg::debugName):
+ (JSC::Reg::dump):
+ * jit/Reg.h:
+ (JSC::Reg::hash):
+ * jsc.cpp: Fix jsc so that it reports the filename and line number of parser errors.
+ (dumpException):
+ * parser/ParserError.h: Make it easier to debug this code.
+ (WTF::printInternal):
+ * runtime/Options.h:
+
</ins><span class="cx"> 2016-06-07 Keith Rollin <krollin@apple.com>
</span><span class="cx">
</span><span class="cx"> Remove all uses of PassRefPtr in WTF
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1983,6 +1983,8 @@
</span><span class="cx"> DC17E81A1C9C91E9008A6AB3 /* CCallHelpers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DC17E8161C9C802B008A6AB3 /* CCallHelpers.cpp */; };
</span><span class="cx"> DC2143071CA32E55000A8869 /* ICStats.h in Headers */ = {isa = PBXBuildFile; fileRef = DC2143061CA32E52000A8869 /* ICStats.h */; };
</span><span class="cx"> DC2143081CA32E58000A8869 /* ICStats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DC2143051CA32E52000A8869 /* ICStats.cpp */; };
</span><ins>+ DC454B8C1D00E822004C18AF /* AirDumpAsJS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DC454B8A1D00E81F004C18AF /* AirDumpAsJS.cpp */; };
+ DC454B8D1D00E824004C18AF /* AirDumpAsJS.h in Headers */ = {isa = PBXBuildFile; fileRef = DC454B8B1D00E81F004C18AF /* AirDumpAsJS.h */; };
</ins><span class="cx"> DC605B5D1CE26EA000593718 /* ProfilerEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DC605B591CE26E9800593718 /* ProfilerEvent.cpp */; };
</span><span class="cx"> DC605B5E1CE26EA200593718 /* ProfilerEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = DC605B5A1CE26E9800593718 /* ProfilerEvent.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="cx"> DC605B5F1CE26EA500593718 /* ProfilerUID.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DC605B5B1CE26E9800593718 /* ProfilerUID.cpp */; };
</span><span class="lines">@@ -4197,6 +4199,8 @@
</span><span class="cx"> DC17E8161C9C802B008A6AB3 /* CCallHelpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CCallHelpers.cpp; sourceTree = "<group>"; };
</span><span class="cx"> DC2143051CA32E52000A8869 /* ICStats.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ICStats.cpp; sourceTree = "<group>"; };
</span><span class="cx"> DC2143061CA32E52000A8869 /* ICStats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ICStats.h; sourceTree = "<group>"; };
</span><ins>+ DC454B8A1D00E81F004C18AF /* AirDumpAsJS.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AirDumpAsJS.cpp; path = b3/air/AirDumpAsJS.cpp; sourceTree = "<group>"; };
+ DC454B8B1D00E81F004C18AF /* AirDumpAsJS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AirDumpAsJS.h; path = b3/air/AirDumpAsJS.h; sourceTree = "<group>"; };
</ins><span class="cx"> DC605B591CE26E9800593718 /* ProfilerEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ProfilerEvent.cpp; path = profiler/ProfilerEvent.cpp; sourceTree = "<group>"; };
</span><span class="cx"> DC605B5A1CE26E9800593718 /* ProfilerEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ProfilerEvent.h; path = profiler/ProfilerEvent.h; sourceTree = "<group>"; };
</span><span class="cx"> DC605B5B1CE26E9800593718 /* ProfilerUID.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ProfilerUID.cpp; path = profiler/ProfilerUID.cpp; sourceTree = "<group>"; };
</span><span class="lines">@@ -4821,6 +4825,8 @@
</span><span class="cx"> 0FEC85511BDACDC70080FF74 /* AirCode.h */,
</span><span class="cx"> 0F6183221C45BF070072450B /* AirCustom.cpp */,
</span><span class="cx"> 0F10F1A21C420BF0001C07D2 /* AirCustom.h */,
</span><ins>+ DC454B8A1D00E81F004C18AF /* AirDumpAsJS.cpp */,
+ DC454B8B1D00E81F004C18AF /* AirDumpAsJS.h */,
</ins><span class="cx"> 0F4570361BE44C910062A629 /* AirEliminateDeadCode.cpp */,
</span><span class="cx"> 0F4570371BE44C910062A629 /* AirEliminateDeadCode.h */,
</span><span class="cx"> 0F6183231C45BF070072450B /* AirEmitShuffle.cpp */,
</span><span class="lines">@@ -7022,6 +7028,7 @@
</span><span class="cx"> 0FEC85061BDACDAC0080FF74 /* B3CheckSpecial.h in Headers */,
</span><span class="cx"> 0FEC85081BDACDAC0080FF74 /* B3CheckValue.h in Headers */,
</span><span class="cx"> 0FEC850A1BDACDAC0080FF74 /* B3Common.h in Headers */,
</span><ins>+ DC454B8D1D00E824004C18AF /* AirDumpAsJS.h in Headers */,
</ins><span class="cx"> 0FEC850C1BDACDAC0080FF74 /* B3Commutativity.h in Headers */,
</span><span class="cx"> 0FEC850E1BDACDAC0080FF74 /* B3Const32Value.h in Headers */,
</span><span class="cx"> 0FEC85101BDACDAC0080FF74 /* B3Const64Value.h in Headers */,
</span><span class="lines">@@ -9106,6 +9113,7 @@
</span><span class="cx"> 140566D6107EC271005DBC8D /* JSFunction.cpp in Sources */,
</span><span class="cx"> 0F4A38F91C8E13DF00190318 /* SuperSampler.cpp in Sources */,
</span><span class="cx"> 797E07A91B8FCFB9008400BA /* JSGlobalLexicalEnvironment.cpp in Sources */,
</span><ins>+ DC454B8C1D00E822004C18AF /* AirDumpAsJS.cpp in Sources */,
</ins><span class="cx"> 147F39D2107EC37600427A48 /* JSGlobalObject.cpp in Sources */,
</span><span class="cx"> A5FD0085189B1B7E00633231 /* JSGlobalObjectConsoleAgent.cpp in Sources */,
</span><span class="cx"> A5C3A1A518C0490200C9593A /* JSGlobalObjectConsoleClient.cpp in Sources */,
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirAllocateStackcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirAllocateStack.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirAllocateStack.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirAllocateStack.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(B3_JIT)
</span><span class="cx">
</span><ins>+#include "AirArgInlines.h"
</ins><span class="cx"> #include "AirCode.h"
</span><span class="cx"> #include "AirInsertionSet.h"
</span><span class="cx"> #include "AirInstInlines.h"
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirArgh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirArg.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirArg.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirArg.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -688,7 +688,15 @@
</span><span class="cx">
</span><span class="cx"> bool isSomeImm() const
</span><span class="cx"> {
</span><del>- return isImm() || isBigImm() || isBitImm() || isBitImm64();
</del><ins>+ switch (kind()) {
+ case Imm:
+ case BigImm:
+ case BitImm:
+ case BitImm64:
+ return true;
+ default:
+ return false;
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool isAddr() const
</span><span class="lines">@@ -993,33 +1001,6 @@
</span><span class="cx"> return tmp().tmpIndex();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- // If 'this' is an address Arg, then it returns a new address Arg with the additional offset applied.
- // Note that this does not consider whether doing so produces a valid Arg or not. Unless you really
- // know what you're doing, you should call Arg::isValidForm() on the result. Some code won't do that,
- // like if you're applying a very small offset to a Arg::stack() that you know has no offset to begin
- // with. It's safe to assume that all targets allow small offsets (like, 0..7) for Addr, Stack, and
- // CallArg.
- Arg withOffset(int64_t additionalOffset) const
- {
- if (!hasOffset())
- return Arg();
- if (sumOverflows<int64_t>(offset(), additionalOffset))
- return Arg();
- switch (kind()) {
- case Addr:
- return addr(base(), offset() + additionalOffset);
- case Stack:
- return stack(stackSlot(), offset() + additionalOffset);
- case CallArg:
- return callArg(offset() + additionalOffset);
- case Index:
- return index(base(), index(), scale(), offset() + additionalOffset);
- default:
- RELEASE_ASSERT_NOT_REACHED();
- return Arg();
- }
- }
-
</del><span class="cx"> static bool isValidImmForm(int64_t value)
</span><span class="cx"> {
</span><span class="cx"> if (isX86())
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirArgInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirArgInlines.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirArgInlines.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirArgInlines.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -84,6 +84,88 @@
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+template<> struct ArgThingHelper<StackSlot*> {
+ static bool is(const Arg& arg)
+ {
+ return arg.isStack();
+ }
+
+ static StackSlot* as(const Arg& arg)
+ {
+ return arg.stackSlot();
+ }
+
+ template<typename Functor>
+ static void forEachFast(Arg& arg, const Functor& functor)
+ {
+ if (!arg.isStack())
+ return;
+
+ StackSlot* stackSlot = arg.stackSlot();
+ functor(stackSlot);
+ arg = Arg::stack(stackSlot, arg.offset());
+ }
+
+ template<typename Functor>
+ static void forEach(Arg& arg, Arg::Role role, Arg::Type type, Arg::Width width, const Functor& functor)
+ {
+ if (!arg.isStack())
+ return;
+
+ StackSlot* stackSlot = arg.stackSlot();
+
+ // FIXME: This is way too optimistic about the meaning of "Def". It gets lucky for
+ // now because our only use of "Anonymous" stack slots happens to want the optimistic
+ // semantics. We could fix this by just changing the comments that describe the
+ // semantics of "Anonymous".
+ // https://bugs.webkit.org/show_bug.cgi?id=151128
+
+ functor(stackSlot, role, type, width);
+ arg = Arg::stack(stackSlot, arg.offset());
+ }
+};
+
+template<> struct ArgThingHelper<Reg> {
+ static bool is(const Arg& arg)
+ {
+ return arg.isReg();
+ }
+
+ static Reg as(const Arg& arg)
+ {
+ return arg.reg();
+ }
+
+ template<typename Functor>
+ static void forEachFast(Arg& arg, const Functor& functor)
+ {
+ arg.forEachTmpFast(
+ [&] (Tmp& tmp) {
+ if (!tmp.isReg())
+ return;
+
+ Reg reg = tmp.reg();
+ functor(reg);
+ tmp = Tmp(reg);
+ });
+ }
+
+ template<typename Functor>
+ static void forEach(Arg& arg, Arg::Role argRole, Arg::Type argType, Arg::Width argWidth, const Functor& functor)
+ {
+ arg.forEachTmp(
+ argRole, argType, argWidth,
+ [&] (Tmp& tmp, Arg::Role role, Arg::Type type, Arg::Width width) {
+ if (!tmp.isReg())
+ return;
+
+ Reg reg = tmp.reg();
+ functor(reg, role, type, width);
+ tmp = Tmp(reg);
+ });
+ }
+};
+
</ins><span class="cx"> template<typename Thing>
</span><span class="cx"> bool Arg::is() const
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirDumpAsJScpp"></a>
<div class="addfile"><h4>Added: trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.cpp (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.cpp (rev 0)
+++ trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,226 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "AirDumpAsJS.h"
+
+#if ENABLE(B3_JIT)
+
+#include "AirCode.h"
+#include "AirInstInlines.h"
+
+namespace JSC { namespace B3 { namespace Air {
+
+namespace {
+
+CString varNameForBlockAtIndex(unsigned index)
+{
+ return toCString("bb", index);
+}
+
+CString varName(BasicBlock* block)
+{
+ return varNameForBlockAtIndex(block->index());
+}
+
+CString varNameForStackSlotAtIndex(unsigned index)
+{
+ return toCString("slot", index);
+}
+
+CString varName(StackSlot* slot)
+{
+ return varNameForStackSlotAtIndex(slot->index());
+}
+
+CString varName(Reg reg)
+{
+ return toCString("Reg.", reg.debugName());
+}
+
+CString varNameForTmpWithTypeAndIndex(Arg::Type type, unsigned index)
+{
+ return toCString(type == Arg::FP ? "f" : "", "tmp", index);
+}
+
+CString varName(Tmp tmp)
+{
+ if (tmp.isReg())
+ return varName(tmp.reg());
+ return varNameForTmpWithTypeAndIndex(Arg(tmp).type(), tmp.tmpIndex());
+}
+
+} // anonymous namespace
+
+void dumpAsJS(Code& code, PrintStream& out)
+{
+ out.println("let code = new Code();");
+
+ for (unsigned i = 0; i < code.size(); ++i)
+ out.println("let ", varNameForBlockAtIndex(i), " = code.addBlock();");
+
+ for (unsigned i = 0; i < code.stackSlots().size(); ++i) {
+ StackSlot* slot = code.stackSlots()[i];
+ if (slot)
+ out.println("let ", varName(slot), " = code.addStackSlot(", slot->byteSize(), ", ", slot->kind(), ");");
+ else
+ out.println("code.addStackSlot(1, Spill);");
+ }
+
+ Arg::forEachType(
+ [&] (Arg::Type type) {
+ for (unsigned i = code.numTmps(type); i--;) {
+ out.println(
+ "let ", varNameForTmpWithTypeAndIndex(type, i), " = code.newTmp(", type, ");");
+ }
+ });
+
+ out.println("let inst;");
+ out.println("let arg;");
+
+ for (BasicBlock* block : code) {
+ for (FrequentedBlock successor : block->successors()) {
+ out.println(
+ varName(block), ".successors.push(new FrequentedBlock(",
+ varName(successor.block()), ", ", successor.frequency(), "));");
+ }
+
+ for (BasicBlock* predecessor : block->predecessors())
+ out.println(varName(block), ".predecessors.push(", varName(predecessor), ");");
+
+ for (Inst& inst : *block) {
+ out.println("inst = new Inst(", inst.opcode, ");");
+
+ inst.forEachArg(
+ [&] (Arg& arg, Arg::Role, Arg::Type, Arg::Width) {
+ switch (arg.kind()) {
+ case Arg::Invalid:
+ RELEASE_ASSERT_NOT_REACHED();
+ break;
+
+ case Arg::Tmp:
+ out.println("arg = Arg.createTmp(", varName(arg.tmp()), ");");
+ break;
+
+ case Arg::Imm:
+ out.println("arg = Arg.createImm(", arg.value(), ");");
+ break;
+
+ case Arg::BigImm:
+ out.println("arg = Arg.createBigImm(", arg.value(), ");");
+ break;
+
+ case Arg::BitImm:
+ out.println("arg = Arg.createBitImm(", arg.value(), ");");
+ break;
+
+ case Arg::BitImm64:
+ out.println("arg = Arg.createBitImm64(", arg.value(), ");");
+ break;
+
+ case Arg::Addr:
+ out.println(
+ "arg = Arg.createAddr(", varName(arg.base()), ", ", arg.offset(), ");");
+ break;
+
+ case Arg::Stack:
+ out.println(
+ "arg = Arg.createStack(", varName(arg.stackSlot()), ", ", arg.offset(), ");");
+ break;
+
+ case Arg::CallArg:
+ out.println("arg = Arg.createCallArg(", arg.offset(), ");");
+ break;
+
+ case Arg::Index:
+ out.println(
+ "arg = Arg.createIndex(", varName(arg.base()), ", ",
+ varName(arg.index()), ", ", arg.scale(), ", ", arg.offset(), ");");
+ break;
+
+ case Arg::RelCond:
+ out.println("arg = Arg.createRelCond(", arg.asRelationalCondition(), ");");
+ break;
+
+ case Arg::ResCond:
+ out.println("arg = Arg.createResCond(", arg.asResultCondition(), ");");
+ break;
+
+ case Arg::DoubleCond:
+ out.println("arg = Arg.createDoubleCond(", arg.asDoubleCondition(), ");");
+ break;
+
+ case Arg::Special:
+ // JS-Air doesn't have Specials.
+ break;
+
+ case Arg::WidthArg:
+ out.println("arg = Arg.createWidthArg(", arg.width(), ");");
+ break;
+ }
+
+ out.println("inst.args.push(arg);");
+ });
+
+ if (inst.opcode == Patch) {
+ if (inst.hasNonArgEffects())
+ out.println("inst.patchHasNonArgEffects = true;");
+
+ out.println("inst.extraEarlyClobberedRegs = new Set();");
+ out.println("inst.extraClobberedRegs = new Set();");
+ inst.extraEarlyClobberedRegs().forEach(
+ [&] (Reg reg) {
+ out.println("inst.extraEarlyClobberedRegs.add(", varName(reg), ");");
+ });
+ inst.extraClobberedRegs().forEach(
+ [&] (Reg reg) {
+ out.println("inst.extraClobberedRegs.add(", varName(reg), ");");
+ });
+
+ out.println("inst.patchArgData = [];");
+ inst.forEachArg(
+ [&] (Arg&, Arg::Role role, Arg::Type type, Arg::Width width) {
+ out.println(
+ "inst.patchArgData.push({role: Arg.", role, ", type: ", type,
+ ", width: ", width, "});");
+ });
+ }
+
+ if (inst.opcode == CCall || inst.opcode == ColdCCall) {
+ out.println("inst.cCallType = ", inst.origin->type());
+ out.println("inst.cCallArgTypes = [];");
+ for (unsigned i = 1; i < inst.origin->numChildren(); ++i)
+ out.println("inst.cCallArgTypes.push(", inst.origin->child(i)->type(), ");");
+ }
+
+ out.println(varName(block), ".append(inst);");
+ }
+ }
+}
+
+} } } // namespace JSC::B3::Air
+
+#endif // ENABLE(B3_JIT)
+
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirDumpAsJSh"></a>
<div class="addfile"><h4>Added: trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.h (0 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.h (rev 0)
+++ trunk/Source/JavaScriptCore/b3/air/AirDumpAsJS.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -0,0 +1,47 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AirDumpAsJS_h
+#define AirDumpAsJS_h
+
+#if ENABLE(B3_JIT)
+
+#include <wtf/PrintStream.h>
+
+namespace JSC { namespace B3 { namespace Air {
+
+class Code;
+
+// This is used for benchmarking. Various operations on Air are interesting from a benchmarking
+// standpoint. We can write some Air phases in JS and then use that to benchmark JS. The benchmark
+// is called JSAir, and it's in PerformanceTests/JSAir.
+void dumpAsJS(Code&, PrintStream&);
+
+} } } // namespace JSC::B3::Air
+
+#endif // ENABLE(B3_JIT)
+
+#endif // AirDumpAsJS_h
+
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirFixObviousSpillscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(B3_JIT)
</span><span class="cx">
</span><ins>+#include "AirArgInlines.h"
</ins><span class="cx"> #include "AirCode.h"
</span><span class="cx"> #include "AirInstInlines.h"
</span><span class="cx"> #include "AirPhaseScope.h"
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirGeneratecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirGenerate.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirGenerate.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirGenerate.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -30,6 +30,7 @@
</span><span class="cx">
</span><span class="cx"> #include "AirAllocateStack.h"
</span><span class="cx"> #include "AirCode.h"
</span><ins>+#include "AirDumpAsJS.h"
</ins><span class="cx"> #include "AirEliminateDeadCode.h"
</span><span class="cx"> #include "AirFixObviousSpills.h"
</span><span class="cx"> #include "AirFixPartialRegisterStalls.h"
</span><span class="lines">@@ -102,11 +103,21 @@
</span><span class="cx"> // Prior to this point the prologue and epilogue is implicit. This makes it explicit. It also
</span><span class="cx"> // does things like identify which callee-saves we're using and saves them.
</span><span class="cx"> handleCalleeSaves(code);
</span><ins>+
+ if (Options::dumpAirAsJSBeforeAllocateStack()) {
+ dataLog("Dumping Air as JS before allocateStack:\n");
+ dumpAsJS(code, WTF::dataFile());
+ }
</ins><span class="cx">
</span><span class="cx"> // This turns all Stack and CallArg Args into Addr args that use the frame pointer. It does
</span><span class="cx"> // this by first-fit allocating stack slots. It should be pretty darn close to optimal, so we
</span><span class="cx"> // shouldn't have to worry about this very much.
</span><span class="cx"> allocateStack(code);
</span><ins>+
+ if (Options::dumpAirAfterAllocateStack()) {
+ dataLog("Dumping Air after allocateStack:\n");
+ dataLog(code);
+ }
</ins><span class="cx">
</span><span class="cx"> // If we coalesced moves then we can unbreak critical edges. This is the main reason for this
</span><span class="cx"> // phase.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirInstInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -36,65 +36,13 @@
</span><span class="cx">
</span><span class="cx"> namespace JSC { namespace B3 { namespace Air {
</span><span class="cx">
</span><del>-template<typename T> struct ForEach;
-template<> struct ForEach<Tmp> {
- template<typename Functor>
- static void forEach(Inst& inst, const Functor& functor)
- {
- inst.forEachTmp(functor);
- }
-};
-
-template<> struct ForEach<Arg> {
- template<typename Functor>
- static void forEach(Inst& inst, const Functor& functor)
- {
- inst.forEachArg(functor);
- }
-};
-
-template<> struct ForEach<StackSlot*> {
- template<typename Functor>
- static void forEach(Inst& inst, const Functor& functor)
- {
- inst.forEachArg(
- [&] (Arg& arg, Arg::Role role, Arg::Type type, Arg::Width width) {
- if (!arg.isStack())
- return;
- StackSlot* stackSlot = arg.stackSlot();
-
- // FIXME: This is way too optimistic about the meaning of "Def". It gets lucky for
- // now because our only use of "Anonymous" stack slots happens to want the optimistic
- // semantics. We could fix this by just changing the comments that describe the
- // semantics of "Anonymous".
- // https://bugs.webkit.org/show_bug.cgi?id=151128
-
- functor(stackSlot, role, type, width);
- arg = Arg::stack(stackSlot, arg.offset());
- });
- }
-};
-
-template<> struct ForEach<Reg> {
- template<typename Functor>
- static void forEach(Inst& inst, const Functor& functor)
- {
- inst.forEachTmp(
- [&] (Tmp& tmp, Arg::Role role, Arg::Type type, Arg::Width width) {
- if (!tmp.isReg())
- return;
-
- Reg reg = tmp.reg();
- functor(reg, role, type, width);
- tmp = Tmp(reg);
- });
- }
-};
-
</del><span class="cx"> template<typename Thing, typename Functor>
</span><span class="cx"> void Inst::forEach(const Functor& functor)
</span><span class="cx"> {
</span><del>- ForEach<Thing>::forEach(*this, functor);
</del><ins>+ forEachArg(
+ [&] (Arg& arg, Arg::Role role, Arg::Type type, Arg::Width width) {
+ arg.forEach<Thing>(role, type, width, functor);
+ });
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline const RegisterSet& Inst::extraClobberedRegs()
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirLogRegisterPressurecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirLogRegisterPressure.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirLogRegisterPressure.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirLogRegisterPressure.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(B3_JIT)
</span><span class="cx">
</span><ins>+#include "AirArgInlines.h"
</ins><span class="cx"> #include "AirCode.h"
</span><span class="cx"> #include "AirInstInlines.h"
</span><span class="cx"> #include "AirLiveness.h"
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirLowerAfterRegAlloccpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(B3_JIT)
</span><span class="cx">
</span><ins>+#include "AirArgInlines.h"
</ins><span class="cx"> #include "AirCCallingConvention.h"
</span><span class="cx"> #include "AirCode.h"
</span><span class="cx"> #include "AirEmitShuffle.h"
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirReportUsedRegisterscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirReportUsedRegisters.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirReportUsedRegisters.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirReportUsedRegisters.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(B3_JIT)
</span><span class="cx">
</span><ins>+#include "AirArgInlines.h"
</ins><span class="cx"> #include "AirCode.h"
</span><span class="cx"> #include "AirInstInlines.h"
</span><span class="cx"> #include "AirLiveness.h"
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirSpillEverythingcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirSpillEverything.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirSpillEverything.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/AirSpillEverything.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(B3_JIT)
</span><span class="cx">
</span><ins>+#include "AirArgInlines.h"
</ins><span class="cx"> #include "AirCode.h"
</span><span class="cx"> #include "AirInsertionSet.h"
</span><span class="cx"> #include "AirInstInlines.h"
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airopcode_generatorrb"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/opcode_generator.rb (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/opcode_generator.rb 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/b3/air/opcode_generator.rb 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1090,3 +1090,96 @@
</span><span class="cx"> outp.puts "} } } // namespace JSC::B3::Air"
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+# This is a hack for JSAir. It's a joke.
+File.open("JSAir_opcode.js", "w") {
+ | outp |
+ outp.puts "\"use strict\";"
+ outp.puts "// Generated by opcode_generator.rb from #{$fileName} -- do not edit!"
+
+ $opcodes.values.each {
+ | opcode |
+ outp.puts "const #{opcode.name} = Symbol(#{opcode.name.inspect});"
+ }
+
+ outp.puts "function Inst_forEachArg(inst, func)"
+ outp.puts "{"
+ outp.puts "let replacement;"
+ outp.puts "switch (inst.opcode) {"
+ $opcodes.values.each {
+ | opcode |
+ outp.puts "case #{opcode.name}:"
+ if opcode.custom
+ outp.puts "#{opcode.name}Custom.forEachArg(inst, func);"
+ else
+ needOverloadSwitch = opcode.overloads.size != 1
+ outp.puts "switch (inst.args.length) {" if needOverloadSwitch
+ opcode.overloads.each {
+ | overload |
+ outp.puts "case #{overload.signature.length}:" if needOverloadSwitch
+ overload.signature.each_with_index {
+ | arg, index |
+ role = nil
+ case arg.role
+ when "U"
+ role = "Use"
+ when "D"
+ role = "Def"
+ when "ZD"
+ role = "ZDef"
+ when "UD"
+ role = "UseDef"
+ when "UZD"
+ role = "UseZDef"
+ when "UA"
+ role = "UseAddr"
+ when "S"
+ role = "Scratch"
+ else
+ raise
+ end
+
+ outp.puts "inst.visitArg(#{index}, func, Arg.#{role}, #{arg.type}P, #{arg.width});"
+ }
+ outp.puts "break;"
+ }
+ if needOverloadSwitch
+ outp.puts "default:"
+ outp.puts "throw new Error(\"Bad overload\");"
+ outp.puts "break;"
+ outp.puts "}"
+ end
+ end
+ outp.puts "break;"
+ }
+ outp.puts "default:"
+ outp.puts "throw \"Bad opcode\";"
+ outp.puts "}"
+ outp.puts "}"
+
+ outp.puts "function Inst_hasNonArgEffects(inst)"
+ outp.puts "{"
+ outp.puts "switch (inst.opcode) {"
+ foundTrue = false
+ $opcodes.values.each {
+ | opcode |
+ if opcode.attributes[:terminal] or opcode.attributes[:effects]
+ outp.puts "case #{opcode.name}:"
+ foundTrue = true
+ end
+ }
+ if foundTrue
+ outp.puts "return true;"
+ end
+ $opcodes.values.each {
+ | opcode |
+ if opcode.custom
+ outp.puts "case #{opcode.name}:"
+ outp.puts "return #{opcode.name}Custom.hasNonArgNonControlEffects(inst);"
+ end
+ }
+ outp.puts "default:"
+ outp.puts "return false;"
+ outp.puts "}"
+ outp.puts "}"
+}
+
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCorejitRegcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/Reg.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/Reg.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/jit/Reg.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1,5 +1,5 @@
</span><span class="cx"> /*
</span><del>- * Copyright (C) 2014 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2014, 2016 Apple Inc. All rights reserved.
</ins><span class="cx"> *
</span><span class="cx"> * Redistribution and use in source and binary forms, with or without
</span><span class="cx"> * modification, are permitted provided that the following conditions
</span><span class="lines">@@ -33,6 +33,15 @@
</span><span class="cx">
</span><span class="cx"> namespace JSC {
</span><span class="cx">
</span><ins>+const char* Reg::debugName() const
+{
+ if (!*this)
+ return nullptr;
+ if (isGPR())
+ return GPRInfo::debugName(gpr());
+ return FPRInfo::debugName(fpr());
+}
+
</ins><span class="cx"> void Reg::dump(PrintStream& out) const
</span><span class="cx"> {
</span><span class="cx"> if (!*this)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitRegh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/Reg.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/Reg.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/jit/Reg.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -172,6 +172,8 @@
</span><span class="cx"> return m_index;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ const char* debugName() const;
+
</ins><span class="cx"> void dump(PrintStream&) const;
</span><span class="cx">
</span><span class="cx"> class AllRegsIterable {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejsccpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jsc.cpp (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jsc.cpp 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/jsc.cpp 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1994,8 +1994,25 @@
</span><span class="cx"> static void dumpException(GlobalObject* globalObject, JSValue exception)
</span><span class="cx"> {
</span><span class="cx"> printf("Exception: %s\n", exception.toWTFString(globalObject->globalExec()).utf8().data());
</span><ins>+
+ Identifier nameID = Identifier::fromString(globalObject->globalExec(), "name");
+ Identifier fileNameID = Identifier::fromString(globalObject->globalExec(), "sourceURL");
+ Identifier lineNumberID = Identifier::fromString(globalObject->globalExec(), "line");
</ins><span class="cx"> Identifier stackID = Identifier::fromString(globalObject->globalExec(), "stack");
</span><ins>+
+ JSValue nameValue = exception.get(globalObject->globalExec(), nameID);
+ JSValue fileNameValue = exception.get(globalObject->globalExec(), fileNameID);
+ JSValue lineNumberValue = exception.get(globalObject->globalExec(), lineNumberID);
</ins><span class="cx"> JSValue stackValue = exception.get(globalObject->globalExec(), stackID);
</span><ins>+
+ if (nameValue.toWTFString(globalObject->globalExec()) == "SyntaxError"
+ && (!fileNameValue.isUndefinedOrNull() || !lineNumberValue.isUndefinedOrNull())) {
+ printf(
+ "at %s:%s\n",
+ fileNameValue.toWTFString(globalObject->globalExec()).utf8().data(),
+ lineNumberValue.toWTFString(globalObject->globalExec()).utf8().data());
+ }
+
</ins><span class="cx"> if (!stackValue.isUndefinedOrNull())
</span><span class="cx"> printf("%s\n", stackValue.toWTFString(globalObject->globalExec()).utf8().data());
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreparserParserErrorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/parser/ParserError.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/parser/ParserError.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/parser/ParserError.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -121,4 +121,51 @@
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span><span class="cx">
</span><ins>+namespace WTF {
+
+inline void printInternal(PrintStream& out, JSC::ParserError::SyntaxErrorType type)
+{
+ switch (type) {
+ case JSC::ParserError::SyntaxErrorNone:
+ out.print("SyntaxErrorNone");
+ return;
+ case JSC::ParserError::SyntaxErrorIrrecoverable:
+ out.print("SyntaxErrorIrrecoverable");
+ return;
+ case JSC::ParserError::SyntaxErrorUnterminatedLiteral:
+ out.print("SyntaxErrorUnterminatedLiteral");
+ return;
+ case JSC::ParserError::SyntaxErrorRecoverable:
+ out.print("SyntaxErrorRecoverable");
+ return;
+ }
+
+ RELEASE_ASSERT_NOT_REACHED();
+}
+
+inline void printInternal(PrintStream& out, JSC::ParserError::ErrorType type)
+{
+ switch (type) {
+ case JSC::ParserError::ErrorNone:
+ out.print("ErrorNone");
+ return;
+ case JSC::ParserError::StackOverflow:
+ out.print("StackOverflow");
+ return;
+ case JSC::ParserError::EvalError:
+ out.print("EvalError");
+ return;
+ case JSC::ParserError::OutOfMemory:
+ out.print("OutOfMemory");
+ return;
+ case JSC::ParserError::SyntaxError:
+ out.print("SyntaxError");
+ return;
+ }
+
+ RELEASE_ASSERT_NOT_REACHED();
+}
+
+} // namespace WTF
+
</ins><span class="cx"> #endif // ParserError_h
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeOptionsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/Options.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/Options.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/JavaScriptCore/runtime/Options.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -368,6 +368,9 @@
</span><span class="cx"> v(bool, dumpModuleLoadingState, false, Normal, nullptr) \
</span><span class="cx"> v(bool, exposeInternalModuleLoader, false, Normal, "expose the internal module loader object to the global space for debugging") \
</span><span class="cx"> \
</span><ins>+ v(bool, dumpAirAsJSBeforeAllocateStack, false, Normal, nullptr) \
+ v(bool, dumpAirAfterAllocateStack, false, Normal, nullptr) \
+ \
</ins><span class="cx"> v(bool, useSuperSampler, false, Normal, nullptr)
</span><span class="cx">
</span><span class="cx"> enum OptionEquivalence {
</span></span></pre></div>
<a id="trunkSourceWTFChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/ChangeLog (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/ChangeLog 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/WTF/ChangeLog 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -1,3 +1,16 @@
</span><ins>+2016-06-07 Filip Pizlo <fpizlo@apple.com>
+
+ Implement Air::allocateStack() in ES6 to see how much of a bad idea that is
+ https://bugs.webkit.org/show_bug.cgi?id=158318
+
+ Reviewed by Saam Barati.
+
+ * wtf/Insertion.h:
+ (WTF::executeInsertions): I found a bug while rewriting this code in JS.
+ * wtf/PrintStream.h:
+ (WTF::PrintStream::print):
+ (WTF::PrintStream::println): This is useful to have.
+
</ins><span class="cx"> 2016-06-07 Keith Rollin <krollin@apple.com>
</span><span class="cx">
</span><span class="cx"> Remove all uses of PassRefPtr in WTF
</span></span></pre></div>
<a id="trunkSourceWTFwtfInsertionh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/wtf/Insertion.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/wtf/Insertion.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/WTF/wtf/Insertion.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -60,12 +60,12 @@
</span><span class="cx"> size_t numInsertions = insertions.size();
</span><span class="cx"> if (!numInsertions)
</span><span class="cx"> return 0;
</span><ins>+ size_t originalTargetSize = target.size();
</ins><span class="cx"> target.grow(target.size() + numInsertions);
</span><span class="cx"> size_t lastIndex = target.size();
</span><del>- size_t originalTargetSize = target.size();
</del><span class="cx"> for (size_t indexInInsertions = numInsertions; indexInInsertions--;) {
</span><span class="cx"> ASSERT(!indexInInsertions || insertions[indexInInsertions].index() >= insertions[indexInInsertions - 1].index());
</span><del>- ASSERT_UNUSED(originalTargetSize, insertions[indexInInsertions].index() < originalTargetSize);
</del><ins>+ ASSERT_UNUSED(originalTargetSize, insertions[indexInInsertions].index() <= originalTargetSize);
</ins><span class="cx"> size_t firstIndex = insertions[indexInInsertions].index() + indexInInsertions;
</span><span class="cx"> size_t indexOffset = indexInInsertions + 1;
</span><span class="cx"> for (size_t i = lastIndex; --i > firstIndex;)
</span></span></pre></div>
<a id="trunkSourceWTFwtfPrintStreamh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/wtf/PrintStream.h (201782 => 201783)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/wtf/PrintStream.h 2016-06-08 01:31:17 UTC (rev 201782)
+++ trunk/Source/WTF/wtf/PrintStream.h 2016-06-08 01:43:35 UTC (rev 201783)
</span><span class="lines">@@ -70,6 +70,13 @@
</span><span class="cx"> printInternal(*this, value);
</span><span class="cx"> print(remainingValues...);
</span><span class="cx"> }
</span><ins>+
+ template<typename... Types>
+ void println(const Types&... values)
+ {
+ print(values...);
+ print("\n");
+ }
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const char*);
</span></span></pre>
</div>
</div>
</body>
</html>