14110 lines
467 KiB
JavaScript
14110 lines
467 KiB
JavaScript
/*
|
|
* Copyright (C) 2016-2018 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");
|
|
|
|
function relCondCode(cond)
|
|
{
|
|
switch (cond) {
|
|
case Equal:
|
|
return 4;
|
|
case NotEqual:
|
|
return 5;
|
|
case Above:
|
|
return 7;
|
|
case AboveOrEqual:
|
|
return 3;
|
|
case Below:
|
|
return 2;
|
|
case BelowOrEqual:
|
|
return 6;
|
|
case GreaterThan:
|
|
return 15;
|
|
case GreaterThanOrEqual:
|
|
return 13;
|
|
case LessThan:
|
|
return 12;
|
|
case LessThanOrEqual:
|
|
return 14;
|
|
default:
|
|
throw new Error("Bad rel cond");
|
|
}
|
|
}
|
|
|
|
// Result conditions
|
|
const Overflow = Symbol("Overflow");
|
|
const Signed = Symbol("Signed");
|
|
const PositiveOrZero = Symbol("PositiveOrZero");
|
|
const Zero = Symbol("Zero");
|
|
const NonZero = Symbol("NonZero");
|
|
|
|
function resCondCode(cond)
|
|
{
|
|
switch (cond) {
|
|
case Overflow:
|
|
return 0;
|
|
case Signed:
|
|
return 8;
|
|
case PositiveOrZero:
|
|
return 9;
|
|
case Zero:
|
|
return 4;
|
|
case NonZero:
|
|
return 5;
|
|
default:
|
|
throw new Error("Bad res cond: " + cond.toString());
|
|
}
|
|
}
|
|
|
|
// 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");
|
|
|
|
function doubleCondCode(cond)
|
|
{
|
|
const bitInvert = 0x10;
|
|
const bitSpecial = 0x20;
|
|
switch (cond) {
|
|
case DoubleEqual:
|
|
return 4 | bitSpecial;
|
|
case DoubleNotEqual:
|
|
return 5;
|
|
case DoubleGreaterThan:
|
|
return 7;
|
|
case DoubleGreaterThanOrEqual:
|
|
return 3;
|
|
case DoubleLessThan:
|
|
return 7 | bitInvert;
|
|
case DoubleLessThanOrEqual:
|
|
return 3 | bitInvert;
|
|
case DoubleEqualOrUnordered:
|
|
return 4;
|
|
case DoubleNotEqualOrUnordered:
|
|
return 5 | bitSpecial;
|
|
case DoubleGreaterThanOrUnordered:
|
|
return 2 | bitInvert;
|
|
case DoubleGreaterThanOrEqualOrUnordered:
|
|
return 6 | bitInvert;
|
|
case DoubleLessThanOrUnordered:
|
|
return 2;
|
|
case DoubleLessThanOrEqualOrUnordered:
|
|
return 6;
|
|
default:
|
|
throw new Error("Bad cond");
|
|
}
|
|
}
|
|
|
|
// Define pointerType()
|
|
const Ptr = 64;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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(lowValue, highValue = 0)
|
|
{
|
|
let result = new Arg();
|
|
result._kind = Arg.BigImm;
|
|
result._lowValue = lowValue;
|
|
result._highValue = highValue;
|
|
return result;
|
|
}
|
|
|
|
static createBitImm(value)
|
|
{
|
|
let result = new Arg();
|
|
result._kind = Arg.BitImm;
|
|
result._value = value;
|
|
return result;
|
|
}
|
|
|
|
static createBitImm64(lowValue, highValue = 0)
|
|
{
|
|
let result = new Arg();
|
|
result._kind = Arg.BitImm64;
|
|
result._lowValue = lowValue;
|
|
result._highValue = highValue;
|
|
return result;
|
|
}
|
|
|
|
static createAddr(base, offset = 0)
|
|
{
|
|
let result = new Arg();
|
|
result._kind = Arg.Addr;
|
|
result._base = base;
|
|
result._offset = offset;
|
|
return result;
|
|
}
|
|
|
|
static createStack(slot, 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 = 1, 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;
|
|
}
|
|
|
|
static createSpecial()
|
|
{
|
|
let result = new Arg();
|
|
result._kind = Arg.Special;
|
|
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.BitImm:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
get isSomeBigImm()
|
|
{
|
|
switch (this._kind) {
|
|
case Arg.BigImm:
|
|
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 isSpecial() { return this._kind == Arg.Special; }
|
|
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 lowValue()
|
|
{
|
|
if (!this.isSomeBigImm)
|
|
throw new Error("Called .lowValue for non-big-imm");
|
|
return this._lowValue;
|
|
}
|
|
|
|
get highValue()
|
|
{
|
|
if (!this.isSomeBigImm)
|
|
throw new Error("Called .highValue for non-big-imm");
|
|
return this._highValue;
|
|
}
|
|
|
|
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:
|
|
case Arg.Special:
|
|
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.Special:
|
|
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:
|
|
case Arg.Special:
|
|
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;
|
|
}
|
|
}
|
|
|
|
static kindCode(kind)
|
|
{
|
|
switch (kind) {
|
|
case Arg.Invalid:
|
|
return 0;
|
|
case Arg.Tmp:
|
|
return 1;
|
|
case Arg.Imm:
|
|
return 2;
|
|
case Arg.BigImm:
|
|
return 3;
|
|
case Arg.BitImm:
|
|
return 4;
|
|
case Arg.BitImm64:
|
|
return 5;
|
|
case Arg.Addr:
|
|
return 6;
|
|
case Arg.Stack:
|
|
return 7;
|
|
case Arg.CallArg:
|
|
return 8;
|
|
case Arg.Index:
|
|
return 9;
|
|
case Arg.RelCond:
|
|
return 10;
|
|
case Arg.ResCond:
|
|
return 11;
|
|
case Arg.DoubleCond:
|
|
return 12;
|
|
case Arg.Special:
|
|
return 13;
|
|
case Arg.WidthArg:
|
|
return 14;
|
|
default:
|
|
throw new Error("Bad kind");
|
|
}
|
|
}
|
|
|
|
hash()
|
|
{
|
|
let result = Arg.kindCode(this._kind);
|
|
|
|
switch (this._kind) {
|
|
case Arg.Invalid:
|
|
case Arg.Special:
|
|
break;
|
|
case Arg.Tmp:
|
|
result += this._tmp.hash();
|
|
result |= 0;
|
|
break;
|
|
case Arg.Imm:
|
|
case Arg.BitImm:
|
|
result += this._value;
|
|
result |= 0;
|
|
break;
|
|
case Arg.BigImm:
|
|
case Arg.BitImm64:
|
|
result += this._lowValue;
|
|
result |= 0;
|
|
result += this._highValue;
|
|
result |= 0;
|
|
break;
|
|
case Arg.CallArg:
|
|
result += this._offset;
|
|
result |= 0;
|
|
break;
|
|
case Arg.RelCond:
|
|
result += relCondCode(this._condition);
|
|
result |= 0;
|
|
break;
|
|
case Arg.ResCond:
|
|
result += resCondCode(this._condition);
|
|
result |= 0;
|
|
break;
|
|
case Arg.DoubleCond:
|
|
result += doubleCondCode(this._condition);
|
|
result |= 0;
|
|
break;
|
|
case Arg.WidthArg:
|
|
result += this._width;
|
|
result |= 0;
|
|
break;
|
|
case Arg.Addr:
|
|
result += this._offset;
|
|
result |= 0;
|
|
result += this._base.hash();
|
|
result |= 0;
|
|
break;
|
|
case Arg.Index:
|
|
result += this._offset;
|
|
result |= 0;
|
|
result += this._scale;
|
|
result |= 0;
|
|
result += this._base.hash();
|
|
result |= 0;
|
|
result += this._index.hash();
|
|
result |= 0;
|
|
break;
|
|
case Arg.Stack:
|
|
result += this._offset;
|
|
result |= 0;
|
|
result += this.stackSlot.index;
|
|
result |= 0;
|
|
break;
|
|
}
|
|
|
|
return result >>> 0;
|
|
}
|
|
|
|
toString()
|
|
{
|
|
switch (this._kind) {
|
|
case Arg.Invalid:
|
|
return "<invalid>";
|
|
case Arg.Tmp:
|
|
return this._tmp.toString();
|
|
case Arg.Imm:
|
|
return "$" + this._value;
|
|
case Arg.BigImm:
|
|
case Arg.BitImm64:
|
|
return "$0x" + this._highValue.toString(16) + ":" + this._lowValue.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:
|
|
return symbolName(this._condition);
|
|
case Arg.Special:
|
|
return "special";
|
|
case Arg.Width:
|
|
return "" + this._value;
|
|
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.Special = Symbol("Special");
|
|
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");
|
|
|
|
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 < 0 || 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 (typeof property == "string"
|
|
&& (property | 0) == property)
|
|
return target[property].block;
|
|
return target[property];
|
|
},
|
|
|
|
set(target, property, value) {
|
|
if (typeof property == "string"
|
|
&& (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;
|
|
}
|
|
}
|
|
|
|
|
|
class Code {
|
|
constructor()
|
|
{
|
|
this._blocks = [];
|
|
this._stackSlots = [];
|
|
this._gpTmps = [];
|
|
this._fpTmps = [];
|
|
this._callArgAreaSize = 0;
|
|
this._frameSize = 0;
|
|
}
|
|
|
|
addBlock(frequency = 1)
|
|
{
|
|
return addIndexed(this._blocks, BasicBlock, frequency);
|
|
}
|
|
|
|
addStackSlot(byteSize, kind)
|
|
{
|
|
return addIndexed(this._stackSlots, StackSlot, byteSize, kind);
|
|
}
|
|
|
|
newTmp(type)
|
|
{
|
|
return addIndexed(this[`_${lowerSymbolName(type)}Tmps`], Tmp, type);
|
|
}
|
|
|
|
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[`_${lowerSymbolName(type)}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; }
|
|
|
|
hash()
|
|
{
|
|
let result = 0;
|
|
for (let block of this) {
|
|
result *= 1000001;
|
|
result |= 0;
|
|
for (let inst of block) {
|
|
result *= 97;
|
|
result |= 0;
|
|
result += inst.hash();
|
|
result |= 0;
|
|
}
|
|
for (let successor of block.successorBlocks) {
|
|
result *= 7;
|
|
result |= 0;
|
|
result += successor.index;
|
|
result |= 0;
|
|
}
|
|
}
|
|
for (let slot of this.stackSlots) {
|
|
result *= 101;
|
|
result |= 0;
|
|
result += slot.hash();
|
|
result |= 0;
|
|
}
|
|
return result >>> 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
class FrequentedBlock {
|
|
constructor(block, frequency)
|
|
{
|
|
this.block = block;
|
|
this.frequency = frequency;
|
|
}
|
|
|
|
toString()
|
|
{
|
|
return (this.frequency == Normal ? "" : "Rare:") + this.block;
|
|
}
|
|
}
|
|
|
|
class Inst {
|
|
constructor(opcode, args = [])
|
|
{
|
|
this._opcode = opcode;
|
|
this._args = 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); }
|
|
|
|
hash()
|
|
{
|
|
let result = opcodeCode(this.opcode);
|
|
for (let arg of this.args) {
|
|
result += arg.hash();
|
|
result |= 0;
|
|
}
|
|
return result >>> 0;
|
|
}
|
|
|
|
toString()
|
|
{
|
|
return "" + symbolName(this._opcode) + " " + this._args.join(", ");
|
|
}
|
|
}
|
|
|
|
"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;
|
|
}
|
|
}
|
|
function opcodeCode(opcode)
|
|
{
|
|
switch (opcode) {
|
|
case AbsDouble:
|
|
return 0
|
|
case AbsFloat:
|
|
return 1
|
|
case Add16:
|
|
return 2
|
|
case Add32:
|
|
return 3
|
|
case Add64:
|
|
return 4
|
|
case Add8:
|
|
return 5
|
|
case AddDouble:
|
|
return 6
|
|
case AddFloat:
|
|
return 7
|
|
case And32:
|
|
return 8
|
|
case And64:
|
|
return 9
|
|
case AndDouble:
|
|
return 10
|
|
case AndFloat:
|
|
return 11
|
|
case Branch32:
|
|
return 12
|
|
case Branch64:
|
|
return 13
|
|
case Branch8:
|
|
return 14
|
|
case BranchAdd32:
|
|
return 15
|
|
case BranchAdd64:
|
|
return 16
|
|
case BranchDouble:
|
|
return 17
|
|
case BranchFloat:
|
|
return 18
|
|
case BranchMul32:
|
|
return 19
|
|
case BranchMul64:
|
|
return 20
|
|
case BranchNeg32:
|
|
return 21
|
|
case BranchNeg64:
|
|
return 22
|
|
case BranchSub32:
|
|
return 23
|
|
case BranchSub64:
|
|
return 24
|
|
case BranchTest32:
|
|
return 25
|
|
case BranchTest64:
|
|
return 26
|
|
case BranchTest8:
|
|
return 27
|
|
case CCall:
|
|
return 28
|
|
case CeilDouble:
|
|
return 29
|
|
case CeilFloat:
|
|
return 30
|
|
case ColdCCall:
|
|
return 31
|
|
case Compare32:
|
|
return 32
|
|
case Compare64:
|
|
return 33
|
|
case CompareDouble:
|
|
return 34
|
|
case CompareFloat:
|
|
return 35
|
|
case ConvertDoubleToFloat:
|
|
return 36
|
|
case ConvertFloatToDouble:
|
|
return 37
|
|
case ConvertInt32ToDouble:
|
|
return 38
|
|
case ConvertInt32ToFloat:
|
|
return 39
|
|
case ConvertInt64ToDouble:
|
|
return 40
|
|
case ConvertInt64ToFloat:
|
|
return 41
|
|
case CountLeadingZeros32:
|
|
return 42
|
|
case CountLeadingZeros64:
|
|
return 43
|
|
case Div32:
|
|
return 44
|
|
case Div64:
|
|
return 45
|
|
case DivDouble:
|
|
return 46
|
|
case DivFloat:
|
|
return 47
|
|
case FloorDouble:
|
|
return 48
|
|
case FloorFloat:
|
|
return 49
|
|
case Jump:
|
|
return 50
|
|
case Lea:
|
|
return 51
|
|
case Load16:
|
|
return 52
|
|
case Load16SignedExtendTo32:
|
|
return 53
|
|
case Load8:
|
|
return 54
|
|
case Load8SignedExtendTo32:
|
|
return 55
|
|
case Lshift32:
|
|
return 56
|
|
case Lshift64:
|
|
return 57
|
|
case Move:
|
|
return 58
|
|
case Move32:
|
|
return 59
|
|
case Move32ToFloat:
|
|
return 60
|
|
case Move64ToDouble:
|
|
return 61
|
|
case MoveConditionally32:
|
|
return 62
|
|
case MoveConditionally64:
|
|
return 63
|
|
case MoveConditionallyDouble:
|
|
return 64
|
|
case MoveConditionallyFloat:
|
|
return 65
|
|
case MoveConditionallyTest32:
|
|
return 66
|
|
case MoveConditionallyTest64:
|
|
return 67
|
|
case MoveDouble:
|
|
return 68
|
|
case MoveDoubleConditionally32:
|
|
return 69
|
|
case MoveDoubleConditionally64:
|
|
return 70
|
|
case MoveDoubleConditionallyDouble:
|
|
return 71
|
|
case MoveDoubleConditionallyFloat:
|
|
return 72
|
|
case MoveDoubleConditionallyTest32:
|
|
return 73
|
|
case MoveDoubleConditionallyTest64:
|
|
return 74
|
|
case MoveDoubleTo64:
|
|
return 75
|
|
case MoveFloat:
|
|
return 76
|
|
case MoveFloatTo32:
|
|
return 77
|
|
case MoveZeroToDouble:
|
|
return 78
|
|
case Mul32:
|
|
return 79
|
|
case Mul64:
|
|
return 80
|
|
case MulDouble:
|
|
return 81
|
|
case MulFloat:
|
|
return 82
|
|
case MultiplyAdd32:
|
|
return 83
|
|
case MultiplyAdd64:
|
|
return 84
|
|
case MultiplyNeg32:
|
|
return 85
|
|
case MultiplyNeg64:
|
|
return 86
|
|
case MultiplySub32:
|
|
return 87
|
|
case MultiplySub64:
|
|
return 88
|
|
case Neg32:
|
|
return 89
|
|
case Neg64:
|
|
return 90
|
|
case NegateDouble:
|
|
return 91
|
|
case Nop:
|
|
return 92
|
|
case Not32:
|
|
return 93
|
|
case Not64:
|
|
return 94
|
|
case Oops:
|
|
return 95
|
|
case Or32:
|
|
return 96
|
|
case Or64:
|
|
return 97
|
|
case Patch:
|
|
return 98
|
|
case Ret32:
|
|
return 99
|
|
case Ret64:
|
|
return 100
|
|
case RetDouble:
|
|
return 101
|
|
case RetFloat:
|
|
return 102
|
|
case Rshift32:
|
|
return 103
|
|
case Rshift64:
|
|
return 104
|
|
case Shuffle:
|
|
return 105
|
|
case SignExtend16To32:
|
|
return 106
|
|
case SignExtend32ToPtr:
|
|
return 107
|
|
case SignExtend8To32:
|
|
return 108
|
|
case SqrtDouble:
|
|
return 109
|
|
case SqrtFloat:
|
|
return 110
|
|
case Store16:
|
|
return 111
|
|
case Store8:
|
|
return 112
|
|
case StoreZero32:
|
|
return 113
|
|
case Sub32:
|
|
return 114
|
|
case Sub64:
|
|
return 115
|
|
case SubDouble:
|
|
return 116
|
|
case SubFloat:
|
|
return 117
|
|
case Swap32:
|
|
return 118
|
|
case Swap64:
|
|
return 119
|
|
case Test32:
|
|
return 120
|
|
case Test64:
|
|
return 121
|
|
case Urshift32:
|
|
return 122
|
|
case Urshift64:
|
|
return 123
|
|
case X86ConvertToDoubleWord32:
|
|
return 124
|
|
case X86ConvertToQuadWord64:
|
|
return 125
|
|
case X86Div32:
|
|
return 126
|
|
case X86Div64:
|
|
return 127
|
|
case Xor32:
|
|
return 128
|
|
case Xor64:
|
|
return 129
|
|
case XorDouble:
|
|
return 130
|
|
case XorFloat:
|
|
return 131
|
|
case ZeroExtend16To32:
|
|
return 132
|
|
case ZeroExtend8To32:
|
|
return 133
|
|
default:
|
|
throw new Error("bad opcode");
|
|
}
|
|
}
|
|
|
|
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; }
|
|
|
|
hash()
|
|
{
|
|
if (this.isGP)
|
|
return 1 + this._index;
|
|
return -1 - this._index;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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; }
|
|
|
|
hash()
|
|
{
|
|
return ((this._kind == Spill ? 1 : 0) + this._byteSize * 3 + (this._offsetFromFP ? this._offsetFromFP * 7 : 0)) >>> 0;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
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; }
|
|
|
|
hash()
|
|
{
|
|
if (isGP)
|
|
return Reg.gprs[Reg.gprs.length - 1].hash() + 1 + this._index;
|
|
return Reg.fprs[Reg.fprs.length - 1].hash() - 1 - this._index;
|
|
}
|
|
|
|
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); }
|
|
}
|
|
|
|
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 lowerSymbolName(symbol)
|
|
{
|
|
return symbolName(symbol).toLowerCase();
|
|
}
|
|
|
|
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(); };
|
|
|
|
|
|
const ShuffleCustom = {
|
|
forEachArg(inst, func)
|
|
{
|
|
var limit = Math.floor(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) {
|
|
let {type, role, width} = inst.patchArgData[i];
|
|
inst.visitArg(i, func, role, type, 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;
|
|
}
|
|
};
|
|
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
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(Array.from(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);
|
|
}
|
|
}
|
|
"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);
|
|
slot12.setOffsetFromFP(-40);
|
|
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(286904960, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(2, -65536);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.r15);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(286506544, 1);
|
|
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(286455168, 1);
|
|
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(287131344, 1);
|
|
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.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(286474592, 1);
|
|
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(287209728, 1);
|
|
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(1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createStack(slot1, 0);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(0, -65536);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.r14);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(287112728, 1);
|
|
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.createBigImm(0, 65536);
|
|
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(287112720, 1);
|
|
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(Move);
|
|
arg = Arg.createBigImm(286506192, 1);
|
|
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(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);
|
|
arg = Arg.createSpecial();
|
|
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(286455168, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rax);
|
|
inst.args.push(arg);
|
|
bb8.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(286455168, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(slot7, 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(slot10, 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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(287112720, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rax);
|
|
inst.args.push(arg);
|
|
bb16.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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(287112720, 1);
|
|
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(287112728, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(287112720, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(0, 65536);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(286474592, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rax);
|
|
inst.args.push(arg);
|
|
bb37.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(286474592, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(286474592, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rax);
|
|
inst.args.push(arg);
|
|
bb39.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(286474592, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(287131344, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rax);
|
|
inst.args.push(arg);
|
|
bb39.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(287131344, 1);
|
|
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(287209728, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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;
|
|
}
|
|
"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);
|
|
slot6.setOffsetFromFP(-40);
|
|
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(144305904, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(142547168, 1);
|
|
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(142547184, 1);
|
|
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(142547192, 1);
|
|
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(142547200, 1);
|
|
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(142547208, 1);
|
|
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(142547216, 1);
|
|
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(142547224, 1);
|
|
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(142547232, 1);
|
|
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(142547240, 1);
|
|
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(0, -65536);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(117076488, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(144506584, 1);
|
|
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(144506544, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rdi);
|
|
inst.args.push(arg);
|
|
bb10.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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(144506544, 1);
|
|
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(144506552, 1);
|
|
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(2, -65536);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(144506576, 1);
|
|
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;
|
|
}
|
|
"use strict";
|
|
// Generated by Air::dumpAsJS from #ACLj8C in Air.js
|
|
function createPayloadAirJSACLj8C()
|
|
{
|
|
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);
|
|
slot4.setOffsetFromFP(-40);
|
|
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(276424800, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(2, -65536);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.r15);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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(0, -65536);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.r14);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(276327648, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rcx);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(372);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(276321024, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rcx);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(468);
|
|
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(276741160, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(275739616, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(276645872, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rax);
|
|
inst.args.push(arg);
|
|
bb4.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(276646496, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(419);
|
|
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(276168608, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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;
|
|
}
|
|
"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);
|
|
slot9.setOffsetFromFP(-40);
|
|
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(177329888, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(2, -65536);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.r15);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(154991936, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rcx);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Patch);
|
|
arg = Arg.createSpecial();
|
|
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(154991936, 1);
|
|
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(154991944, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(129987312, 1);
|
|
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(108418352, 1);
|
|
inst.args.push(arg);
|
|
arg = Arg.createTmp(Reg.rcx);
|
|
inst.args.push(arg);
|
|
bb0.append(inst);
|
|
inst = new Inst(Move);
|
|
arg = Arg.createBigImm(0, -65536);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(129987312, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(155021568, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(155041288, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(108356304, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(129987312, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(154991632, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
inst.args.push(arg);
|
|
arg = Arg.createBigImm(108356304, 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.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(129987312, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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(153835296, 1);
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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);
|
|
arg = Arg.createSpecial();
|
|
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;
|
|
}
|
|
|
|
class AirBenchmark {
|
|
constructor(verbose = 0)
|
|
{
|
|
this._verbose = verbose;
|
|
|
|
this._payloads = [
|
|
{generate: createPayloadGbemuExecuteIteration, earlyHash: 632653144, lateHash: 372715518},
|
|
{generate: createPayloadImagingGaussianBlurGaussianBlur, earlyHash: 3677819581, lateHash: 1252116304},
|
|
{generate: createPayloadTypescriptScanIdentifier, earlyHash: 1914852601, lateHash: 837339551},
|
|
{generate: createPayloadAirJSACLj8C, earlyHash: 1373599940, lateHash: 3981283600}
|
|
];
|
|
}
|
|
|
|
runIteration()
|
|
{
|
|
for (let payload of this._payloads) {
|
|
// Sadly about 17% of our time is in generate. I don't think that's really avoidable,
|
|
// and I don't mind testing VMs' ability to run such "data definition" code quickly. I
|
|
// would not have expected it to be so slow from first principles!
|
|
let code = payload.generate();
|
|
|
|
if (this._verbose) {
|
|
print("Before allocateStack:");
|
|
print(code);
|
|
}
|
|
|
|
let hash = code.hash();
|
|
if (hash != payload.earlyHash)
|
|
throw new Error(`Wrong early hash for ${payload.generate.name}: ${hash}`);
|
|
|
|
allocateStack(code);
|
|
|
|
if (this._verbose) {
|
|
print("After allocateStack:");
|
|
print(code);
|
|
}
|
|
|
|
hash = code.hash();
|
|
if (hash != payload.lateHash)
|
|
throw new Error(`Wrong late hash for ${payload.generate.name}: ${hash}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
function runBenchmark()
|
|
{
|
|
const verbose = 0;
|
|
const numIterations = 5;
|
|
|
|
let before = currentTime();
|
|
let benchmark = new AirBenchmark(verbose);
|
|
|
|
for (let iteration = 0; iteration < numIterations; ++iteration)
|
|
benchmark.runIteration();
|
|
|
|
let after = currentTime();
|
|
return after - before;
|
|
}
|
|
runBenchmark();
|