* Copyright (C) 2016 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
"use strict";
class Arg {
constructor()
{
this._kind = Arg.Invalid;
}
static isAnyUse(role)
{
switch (role) {
case Arg.Use:
case Arg.ColdUse:
case Arg.UseDef:
case Arg.UseZDef:
case Arg.LateUse:
case Arg.LateColdUse:
case Arg.Scratch:
return true;
case Arg.Def:
case Arg.ZDef:
case Arg.UseAddr:
case Arg.EarlyDef:
return false;
default:
throw new Error("Bad role");
}
}
static isColdUse(role)
{
switch (role) {
case Arg.ColdUse:
case Arg.LateColdUse:
return true;
case Arg.Use:
case Arg.UseDef:
case Arg.UseZDef:
case Arg.LateUse:
case Arg.Def:
case Arg.ZDef:
case Arg.UseAddr:
case Arg.Scratch:
case Arg.EarlyDef:
return false;
default:
throw new Error("Bad role");
}
}
static isWarmUse(role)
{
return Arg.isAnyUse(role) && !Arg.isColdUse(role);
}
static cooled(role)
{
switch (role) {
case Arg.ColdUse:
case Arg.LateColdUse:
case Arg.UseDef:
case Arg.UseZDef:
case Arg.Def:
case Arg.ZDef:
case Arg.UseAddr:
case Arg.Scratch:
case Arg.EarlyDef:
return role;
case Arg.Use:
return Arg.ColdUse;
case Arg.LateUse:
return Arg.LateColdUse;
default:
throw new Error("Bad role");
}
}
static isEarlyUse(role)
{
switch (role) {
case Arg.Use:
case Arg.ColdUse:
case Arg.UseDef:
case Arg.UseZDef:
return true;
case Arg.Def:
case Arg.ZDef:
case Arg.UseAddr:
case Arg.LateUse:
case Arg.LateColdUse:
case Arg.Scratch:
case Arg.EarlyDef:
return false;
default:
throw new Error("Bad role");
}
}
static isLateUse(role)
{
switch (role) {
case Arg.LateUse:
case Arg.LateColdUse:
case Arg.Scratch:
return true;
case Arg.ColdUse:
case Arg.Use:
case Arg.UseDef:
case Arg.UseZDef:
case Arg.Def:
case Arg.ZDef:
case Arg.UseAddr:
case Arg.EarlyDef:
return false;
default:
throw new Error("Bad role");
}
}
static isAnyDef(role)
{
switch (role) {
case Arg.Use:
case Arg.ColdUse:
case Arg.UseAddr:
case Arg.LateUse:
case Arg.LateColdUse:
return false;
case Arg.Def:
case Arg.UseDef:
case Arg.ZDef:
case Arg.UseZDef:
case Arg.EarlyDef:
case Arg.Scratch:
return true;
default:
throw new Error("Bad role");
}
}
static isEarlyDef(role)
{
switch (role) {
case Arg.Use:
case Arg.ColdUse:
case Arg.UseAddr:
case Arg.LateUse:
case Arg.Def:
case Arg.UseDef:
case Arg.ZDef:
case Arg.UseZDef:
case Arg.LateColdUse:
return false;
case Arg.EarlyDef:
case Arg.Scratch:
return true;
default:
throw new Error("Bad role");
}
}
static isLateDef(role)
{
switch (role) {
case Arg.Use:
case Arg.ColdUse:
case Arg.UseAddr:
case Arg.LateUse:
case Arg.EarlyDef:
case Arg.Scratch:
case Arg.LateColdUse:
return false;
case Arg.Def:
case Arg.UseDef:
case Arg.ZDef:
case Arg.UseZDef:
return true;
default:
throw new Error("Bad role");
}
}
static isZDef(role)
{
switch (role) {
case Arg.Use:
case Arg.ColdUse:
case Arg.UseAddr:
case Arg.LateUse:
case Arg.Def:
case Arg.UseDef:
case Arg.EarlyDef:
case Arg.Scratch:
case Arg.LateColdUse:
return false;
case Arg.ZDef:
case Arg.UseZDef:
return true;
default:
throw new Error("Bad role");
}
}
static typeForB3Type(type)
{
switch (type) {
case Int32:
case Int64:
return GP;
case Float:
case Double:
return FP;
default:
throw new Error("Bad B3 type");
}
}
static widthForB3Type(type)
{
switch (type) {
case Int32:
case Float:
return 32;
case Int64:
case Double:
return 64;
default:
throw new Error("Bad B3 type");
}
}
static conservativeWidth(type)
{
return type == GP ? Ptr : 64;
}
static minimumWidth(type)
{
return type == GP ? 8 : 32;
}
static bytes(width)
{
return width / 8;
}
static widthForBytes(bytes)
{
switch (bytes) {
case 0:
case 1:
return 8;
case 2:
return 16;
case 3:
case 4:
return 32;
default:
if (bytes > 8)
throw new Error("Bad number of bytes");
return 64;
}
}
static createTmp(tmp)
{
let result = new Arg();
result._kind = Arg.Tmp;
result._tmp = tmp;
return result;
}
static fromReg(reg)
{
return Arg.createTmp(reg);
}
static createImm(value)
{
let result = new Arg();
result._kind = Arg.Imm;
result._value = value;
return result;
}
static createBigImm(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); }
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.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.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");
