1  /*
  2   * Copyright (C) 2015-2017 Apple Inc. All rights reserved.
  3   *
  4   * Redistribution and use in source and binary forms, with or without
  5   * modification, are permitted provided that the following conditions
  6   * are met:
  7   * 1. Redistributions of source code must retain the above copyright
  8   *    notice, this list of conditions and the following disclaimer.
  9   * 2. Redistributions in binary form must reproduce the above copyright
 10   *    notice, this list of conditions and the following disclaimer in the
 11   *    documentation and/or other materials provided with the distribution.
 12   *
 13   * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 14   * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 15   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 16   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 17   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 18   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 19   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 20   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 21   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 22   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 23   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 24   */
 25  
 26  #include "config.h"
 27  #include "B3Opcode.h"
 28  
 29  #if ENABLE(B3_JIT)
 30  
 31  #include <wtf/PrintStream.h>
 32  
 33  #if !ASSERT_ENABLED
 34  IGNORE_RETURN_TYPE_WARNINGS_BEGIN
 35  #endif
 36  
 37  namespace JSC { namespace B3 {
 38  
 39  Optional<Opcode> invertedCompare(Opcode opcode, Type type)
 40  {
 41      switch (opcode) {
 42      case Equal:
 43          return NotEqual;
 44      case NotEqual:
 45          return Equal;
 46      case LessThan:
 47          if (type.isInt())
 48              return GreaterEqual;
 49          return WTF::nullopt;
 50      case GreaterThan:
 51          if (type.isInt())
 52              return LessEqual;
 53          return WTF::nullopt;
 54      case LessEqual:
 55          if (type.isInt())
 56              return GreaterThan;
 57          return WTF::nullopt;
 58      case GreaterEqual:
 59          if (type.isInt())
 60              return LessThan;
 61          return WTF::nullopt;
 62      case Above:
 63          return BelowEqual;
 64      case Below:
 65          return AboveEqual;
 66      case AboveEqual:
 67          return Below;
 68      case BelowEqual:
 69          return Above;
 70      default:
 71          return WTF::nullopt;
 72      }
 73  }
 74  
 75  Opcode storeOpcode(Bank bank, Width width)
 76  {
 77      switch (bank) {
 78      case GP:
 79          switch (width) {
 80          case Width8:
 81              return Store8;
 82          case Width16:
 83              return Store16;
 84          default:
 85              return Store;
 86          }
 87      case FP:
 88          return Store;
 89      }
 90      ASSERT_NOT_REACHED();
 91  }
 92  
 93  } } // namespace JSC::B3
 94  
 95  namespace WTF {
 96  
 97  using namespace JSC::B3;
 98  
 99  void printInternal(PrintStream& out, Opcode opcode)
100  {
101      switch (opcode) {
102      case Nop:
103          out.print("Nop");
104          return;
105      case Identity:
106          out.print("Identity");
107          return;
108      case Opaque:
109          out.print("Opaque");
110          return;
111      case Const32:
112          out.print("Const32");
113          return;
114      case Const64:
115          out.print("Const64");
116          return;
117      case ConstDouble:
118          out.print("ConstDouble");
119          return;
120      case ConstFloat:
121          out.print("ConstFloat");
122          return;
123      case BottomTuple:
124          out.print("BottomTuple");
125          return;
126      case Get:
127          out.print("Get");
128          return;
129      case Set:
130          out.print("Set");
131          return;
132      case SlotBase:
133          out.print("SlotBase");
134          return;
135      case ArgumentReg:
136          out.print("ArgumentReg");
137          return;
138      case FramePointer:
139          out.print("FramePointer");
140          return;
141      case Add:
142          out.print("Add");
143          return;
144      case Sub:
145          out.print("Sub");
146          return;
147      case Mul:
148          out.print("Mul");
149          return;
150      case Div:
151          out.print("Div");
152          return;
153      case UDiv:
154          out.print("UDiv");
155          return;
156      case Mod:
157          out.print("Mod");
158          return;
159      case UMod:
160          out.print("UMod");
161          return;
162      case Neg:
163          out.print("Neg");
164          return;
165      case BitAnd:
166          out.print("BitAnd");
167          return;
168      case BitOr:
169          out.print("BitOr");
170          return;
171      case BitXor:
172          out.print("BitXor");
173          return;
174      case Shl:
175          out.print("Shl");
176          return;
177      case SShr:
178          out.print("SShr");
179          return;
180      case ZShr:
181          out.print("ZShr");
182          return;
183      case RotR:
184          out.print("RotR");
185          return;
186      case RotL:
187          out.print("RotL");
188          return;
189      case Clz:
190          out.print("Clz");
191          return;
192      case Abs:
193          out.print("Abs");
194          return;
195      case Ceil:
196          out.print("Ceil");
197          return;
198      case Floor:
199          out.print("Floor");
200          return;
201      case Sqrt:
202          out.print("Sqrt");
203          return;
204      case BitwiseCast:
205          out.print("BitwiseCast");
206          return;
207      case SExt8:
208          out.print("SExt8");
209          return;
210      case SExt16:
211          out.print("SExt16");
212          return;
213      case SExt32:
214          out.print("SExt32");
215          return;
216      case ZExt32:
217          out.print("ZExt32");
218          return;
219      case Trunc:
220          out.print("Trunc");
221          return;
222      case IToD:
223          out.print("IToD");
224          return;
225      case IToF:
226          out.print("IToF");
227          return;
228      case FloatToDouble:
229          out.print("FloatToDouble");
230          return;
231      case DoubleToFloat:
232          out.print("DoubleToFloat");
233          return;
234      case Equal:
235          out.print("Equal");
236          return;
237      case NotEqual:
238          out.print("NotEqual");
239          return;
240      case LessThan:
241          out.print("LessThan");
242          return;
243      case GreaterThan:
244          out.print("GreaterThan");
245          return;
246      case LessEqual:
247          out.print("LessEqual");
248          return;
249      case GreaterEqual:
250          out.print("GreaterEqual");
251          return;
252      case Above:
253          out.print("Above");
254          return;
255      case Below:
256          out.print("Below");
257          return;
258      case AboveEqual:
259          out.print("AboveEqual");
260          return;
261      case BelowEqual:
262          out.print("BelowEqual");
263          return;
264      case EqualOrUnordered:
265          out.print("EqualOrUnordered");
266          return;
267      case Select:
268          out.print("Select");
269          return;
270      case Load8Z:
271          out.print("Load8Z");
272          return;
273      case Load8S:
274          out.print("Load8S");
275          return;
276      case Load16Z:
277          out.print("Load16Z");
278          return;
279      case Load16S:
280          out.print("Load16S");
281          return;
282      case Load:
283          out.print("Load");
284          return;
285      case Store8:
286          out.print("Store8");
287          return;
288      case Store16:
289          out.print("Store16");
290          return;
291      case Store:
292          out.print("Store");
293          return;
294      case AtomicWeakCAS:
295          out.print("AtomicWeakCAS");
296          return;
297      case AtomicStrongCAS:
298          out.print("AtomicStrongCAS");
299          return;
300      case AtomicXchgAdd:
301          out.print("AtomicXchgAdd");
302          return;
303      case AtomicXchgAnd:
304          out.print("AtomicXchgAnd");
305          return;
306      case AtomicXchgOr:
307          out.print("AtomicXchgOr");
308          return;
309      case AtomicXchgSub:
310          out.print("AtomicXchgSub");
311          return;
312      case AtomicXchgXor:
313          out.print("AtomicXchgXor");
314          return;
315      case AtomicXchg:
316          out.print("AtomicXchg");
317          return;
318      case Depend:
319          out.print("Depend");
320          return;
321      case WasmAddress:
322          out.print("WasmAddress");
323          return;
324      case Fence:
325          out.print("Fence");
326          return;
327      case CCall:
328          out.print("CCall");
329          return;
330      case Patchpoint:
331          out.print("Patchpoint");
332          return;
333      case Extract:
334          out.print("Extract");
335          return;
336      case CheckAdd:
337          out.print("CheckAdd");
338          return;
339      case CheckSub:
340          out.print("CheckSub");
341          return;
342      case CheckMul:
343          out.print("CheckMul");
344          return;
345      case Check:
346          out.print("Check");
347          return;
348      case WasmBoundsCheck:
349          out.print("WasmBoundsCheck");
350          return;
351      case Upsilon:
352          out.print("Upsilon");
353          return;
354      case Phi:
355          out.print("Phi");
356          return;
357      case Jump:
358          out.print("Jump");
359          return;
360      case Branch:
361          out.print("Branch");
362          return;
363      case Switch:
364          out.print("Switch");
365          return;
366      case EntrySwitch:
367          out.print("EntrySwitch");
368          return;
369      case Return:
370          out.print("Return");
371          return;
372      case Oops:
373          out.print("Oops");
374          return;
375      }
376      RELEASE_ASSERT_NOT_REACHED();
377  }
378  
379  } // namespace WTF
380  
381  #if !ASSERT_ENABLED
382  IGNORE_RETURN_TYPE_WARNINGS_END
383  #endif
384  
385  #endif // ENABLE(B3_JIT)