| /* | 
 |  * Copyright (C) 2015-2017 Apple Inc. All rights reserved. | 
 |  * | 
 |  * Redistribution and use in source and binary forms, with or without | 
 |  * modification, are permitted provided that the following conditions | 
 |  * are met: | 
 |  * 1. Redistributions of source code must retain the above copyright | 
 |  *    notice, this list of conditions and the following disclaimer. | 
 |  * 2. Redistributions in binary form must reproduce the above copyright | 
 |  *    notice, this list of conditions and the following disclaimer in the | 
 |  *    documentation and/or other materials provided with the distribution. | 
 |  * | 
 |  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY | 
 |  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | 
 |  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | 
 |  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR | 
 |  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | 
 |  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | 
 |  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | 
 |  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY | 
 |  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 
 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 
 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  | 
 |  */ | 
 |  | 
 | #include "config.h" | 
 | #include "B3Opcode.h" | 
 |  | 
 | #if ENABLE(B3_JIT) | 
 |  | 
 | #include <wtf/PrintStream.h> | 
 |  | 
 | #if !ASSERT_ENABLED | 
 | IGNORE_RETURN_TYPE_WARNINGS_BEGIN | 
 | #endif | 
 |  | 
 | namespace JSC { namespace B3 { | 
 |  | 
 | std::optional<Opcode> invertedCompare(Opcode opcode, Type type) | 
 | { | 
 |     switch (opcode) { | 
 |     case Equal: | 
 |         return NotEqual; | 
 |     case NotEqual: | 
 |         return Equal; | 
 |     case LessThan: | 
 |         if (type.isInt()) | 
 |             return GreaterEqual; | 
 |         return std::nullopt; | 
 |     case GreaterThan: | 
 |         if (type.isInt()) | 
 |             return LessEqual; | 
 |         return std::nullopt; | 
 |     case LessEqual: | 
 |         if (type.isInt()) | 
 |             return GreaterThan; | 
 |         return std::nullopt; | 
 |     case GreaterEqual: | 
 |         if (type.isInt()) | 
 |             return LessThan; | 
 |         return std::nullopt; | 
 |     case Above: | 
 |         return BelowEqual; | 
 |     case Below: | 
 |         return AboveEqual; | 
 |     case AboveEqual: | 
 |         return Below; | 
 |     case BelowEqual: | 
 |         return Above; | 
 |     default: | 
 |         return std::nullopt; | 
 |     } | 
 | } | 
 |  | 
 | Opcode storeOpcode(Bank bank, Width width) | 
 | { | 
 |     switch (bank) { | 
 |     case GP: | 
 |         switch (width) { | 
 |         case Width8: | 
 |             return Store8; | 
 |         case Width16: | 
 |             return Store16; | 
 |         default: | 
 |             return Store; | 
 |         } | 
 |     case FP: | 
 |         return Store; | 
 |     } | 
 |     ASSERT_NOT_REACHED(); | 
 | } | 
 |  | 
 | } } // namespace JSC::B3 | 
 |  | 
 | namespace WTF { | 
 |  | 
 | using namespace JSC::B3; | 
 |  | 
 | void printInternal(PrintStream& out, Opcode opcode) | 
 | { | 
 |     switch (opcode) { | 
 |     case Nop: | 
 |         out.print("Nop"); | 
 |         return; | 
 |     case Identity: | 
 |         out.print("Identity"); | 
 |         return; | 
 |     case Opaque: | 
 |         out.print("Opaque"); | 
 |         return; | 
 |     case Const32: | 
 |         out.print("Const32"); | 
 |         return; | 
 |     case Const64: | 
 |         out.print("Const64"); | 
 |         return; | 
 |     case ConstDouble: | 
 |         out.print("ConstDouble"); | 
 |         return; | 
 |     case ConstFloat: | 
 |         out.print("ConstFloat"); | 
 |         return; | 
 |     case BottomTuple: | 
 |         out.print("BottomTuple"); | 
 |         return; | 
 |     case Get: | 
 |         out.print("Get"); | 
 |         return; | 
 |     case Set: | 
 |         out.print("Set"); | 
 |         return; | 
 |     case SlotBase: | 
 |         out.print("SlotBase"); | 
 |         return; | 
 |     case ArgumentReg: | 
 |         out.print("ArgumentReg"); | 
 |         return; | 
 |     case FramePointer: | 
 |         out.print("FramePointer"); | 
 |         return; | 
 |     case Add: | 
 |         out.print("Add"); | 
 |         return; | 
 |     case Sub: | 
 |         out.print("Sub"); | 
 |         return; | 
 |     case Mul: | 
 |         out.print("Mul"); | 
 |         return; | 
 |     case Div: | 
 |         out.print("Div"); | 
 |         return; | 
 |     case UDiv: | 
 |         out.print("UDiv"); | 
 |         return; | 
 |     case Mod: | 
 |         out.print("Mod"); | 
 |         return; | 
 |     case UMod: | 
 |         out.print("UMod"); | 
 |         return; | 
 |     case FMin: | 
 |         out.print("FMin"); | 
 |         return; | 
 |     case FMax: | 
 |         out.print("FMax"); | 
 |         return; | 
 |     case Neg: | 
 |         out.print("Neg"); | 
 |         return; | 
 |     case BitAnd: | 
 |         out.print("BitAnd"); | 
 |         return; | 
 |     case BitOr: | 
 |         out.print("BitOr"); | 
 |         return; | 
 |     case BitXor: | 
 |         out.print("BitXor"); | 
 |         return; | 
 |     case Shl: | 
 |         out.print("Shl"); | 
 |         return; | 
 |     case SShr: | 
 |         out.print("SShr"); | 
 |         return; | 
 |     case ZShr: | 
 |         out.print("ZShr"); | 
 |         return; | 
 |     case RotR: | 
 |         out.print("RotR"); | 
 |         return; | 
 |     case RotL: | 
 |         out.print("RotL"); | 
 |         return; | 
 |     case Clz: | 
 |         out.print("Clz"); | 
 |         return; | 
 |     case Abs: | 
 |         out.print("Abs"); | 
 |         return; | 
 |     case Ceil: | 
 |         out.print("Ceil"); | 
 |         return; | 
 |     case Floor: | 
 |         out.print("Floor"); | 
 |         return; | 
 |     case Sqrt: | 
 |         out.print("Sqrt"); | 
 |         return; | 
 |     case BitwiseCast: | 
 |         out.print("BitwiseCast"); | 
 |         return; | 
 |     case SExt8: | 
 |         out.print("SExt8"); | 
 |         return; | 
 |     case SExt16: | 
 |         out.print("SExt16"); | 
 |         return; | 
 |     case SExt32: | 
 |         out.print("SExt32"); | 
 |         return; | 
 |     case ZExt32: | 
 |         out.print("ZExt32"); | 
 |         return; | 
 |     case Trunc: | 
 |         out.print("Trunc"); | 
 |         return; | 
 |     case IToD: | 
 |         out.print("IToD"); | 
 |         return; | 
 |     case IToF: | 
 |         out.print("IToF"); | 
 |         return; | 
 |     case FloatToDouble: | 
 |         out.print("FloatToDouble"); | 
 |         return; | 
 |     case DoubleToFloat: | 
 |         out.print("DoubleToFloat"); | 
 |         return; | 
 |     case Equal: | 
 |         out.print("Equal"); | 
 |         return; | 
 |     case NotEqual: | 
 |         out.print("NotEqual"); | 
 |         return; | 
 |     case LessThan: | 
 |         out.print("LessThan"); | 
 |         return; | 
 |     case GreaterThan: | 
 |         out.print("GreaterThan"); | 
 |         return; | 
 |     case LessEqual: | 
 |         out.print("LessEqual"); | 
 |         return; | 
 |     case GreaterEqual: | 
 |         out.print("GreaterEqual"); | 
 |         return; | 
 |     case Above: | 
 |         out.print("Above"); | 
 |         return; | 
 |     case Below: | 
 |         out.print("Below"); | 
 |         return; | 
 |     case AboveEqual: | 
 |         out.print("AboveEqual"); | 
 |         return; | 
 |     case BelowEqual: | 
 |         out.print("BelowEqual"); | 
 |         return; | 
 |     case EqualOrUnordered: | 
 |         out.print("EqualOrUnordered"); | 
 |         return; | 
 |     case Select: | 
 |         out.print("Select"); | 
 |         return; | 
 |     case Load8Z: | 
 |         out.print("Load8Z"); | 
 |         return; | 
 |     case Load8S: | 
 |         out.print("Load8S"); | 
 |         return; | 
 |     case Load16Z: | 
 |         out.print("Load16Z"); | 
 |         return; | 
 |     case Load16S: | 
 |         out.print("Load16S"); | 
 |         return; | 
 |     case Load: | 
 |         out.print("Load"); | 
 |         return; | 
 |     case Store8: | 
 |         out.print("Store8"); | 
 |         return; | 
 |     case Store16: | 
 |         out.print("Store16"); | 
 |         return; | 
 |     case Store: | 
 |         out.print("Store"); | 
 |         return; | 
 |     case AtomicWeakCAS: | 
 |         out.print("AtomicWeakCAS"); | 
 |         return; | 
 |     case AtomicStrongCAS: | 
 |         out.print("AtomicStrongCAS"); | 
 |         return; | 
 |     case AtomicXchgAdd: | 
 |         out.print("AtomicXchgAdd"); | 
 |         return; | 
 |     case AtomicXchgAnd: | 
 |         out.print("AtomicXchgAnd"); | 
 |         return; | 
 |     case AtomicXchgOr: | 
 |         out.print("AtomicXchgOr"); | 
 |         return; | 
 |     case AtomicXchgSub: | 
 |         out.print("AtomicXchgSub"); | 
 |         return; | 
 |     case AtomicXchgXor: | 
 |         out.print("AtomicXchgXor"); | 
 |         return; | 
 |     case AtomicXchg: | 
 |         out.print("AtomicXchg"); | 
 |         return; | 
 |     case Depend: | 
 |         out.print("Depend"); | 
 |         return; | 
 |     case WasmAddress: | 
 |         out.print("WasmAddress"); | 
 |         return; | 
 |     case Fence: | 
 |         out.print("Fence"); | 
 |         return; | 
 |     case CCall: | 
 |         out.print("CCall"); | 
 |         return; | 
 |     case Patchpoint: | 
 |         out.print("Patchpoint"); | 
 |         return; | 
 |     case Extract: | 
 |         out.print("Extract"); | 
 |         return; | 
 |     case CheckAdd: | 
 |         out.print("CheckAdd"); | 
 |         return; | 
 |     case CheckSub: | 
 |         out.print("CheckSub"); | 
 |         return; | 
 |     case CheckMul: | 
 |         out.print("CheckMul"); | 
 |         return; | 
 |     case Check: | 
 |         out.print("Check"); | 
 |         return; | 
 |     case WasmBoundsCheck: | 
 |         out.print("WasmBoundsCheck"); | 
 |         return; | 
 |     case Upsilon: | 
 |         out.print("Upsilon"); | 
 |         return; | 
 |     case Phi: | 
 |         out.print("Phi"); | 
 |         return; | 
 |     case Jump: | 
 |         out.print("Jump"); | 
 |         return; | 
 |     case Branch: | 
 |         out.print("Branch"); | 
 |         return; | 
 |     case Switch: | 
 |         out.print("Switch"); | 
 |         return; | 
 |     case EntrySwitch: | 
 |         out.print("EntrySwitch"); | 
 |         return; | 
 |     case Return: | 
 |         out.print("Return"); | 
 |         return; | 
 |     case Oops: | 
 |         out.print("Oops"); | 
 |         return; | 
 |     } | 
 |     RELEASE_ASSERT_NOT_REACHED(); | 
 | } | 
 |  | 
 | } // namespace WTF | 
 |  | 
 | #if !ASSERT_ENABLED | 
 | IGNORE_RETURN_TYPE_WARNINGS_END | 
 | #endif | 
 |  | 
 | #endif // ENABLE(B3_JIT) |