diff options
Diffstat (limited to 'third_party/webkit/PerformanceTests/ARES-6/Air/arg.js')
| -rw-r--r-- | third_party/webkit/PerformanceTests/ARES-6/Air/arg.js | 1064 |
1 files changed, 1064 insertions, 0 deletions
diff --git a/third_party/webkit/PerformanceTests/ARES-6/Air/arg.js b/third_party/webkit/PerformanceTests/ARES-6/Air/arg.js new file mode 100644 index 0000000000..07aceda8d5 --- /dev/null +++ b/third_party/webkit/PerformanceTests/ARES-6/Air/arg.js @@ -0,0 +1,1064 @@ +/* + * 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); } + + // 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"); + |