dfg/DFGFlushFormat.h

   1 /*
   2  * Copyright (C) 2013-2015 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 #ifndef DFGFlushFormat_h
  27 #define DFGFlushFormat_h
  28
  29 #if ENABLE(DFG_JIT)
  30
  31 #include "DFGNodeFlags.h"
  32 #include "DFGUseKind.h"
  33 #include "DataFormat.h"
  34 #include "DumpContext.h"
  35 #include <wtf/PrintStream.h>
  36
  37 namespace JSC { namespace DFG {
  38
  39 enum FlushFormat {
  40     DeadFlush,
  41     FlushedInt32,
  42     FlushedInt52,
  43     FlushedDouble,
  44     FlushedCell,
  45     FlushedBoolean,
  46     FlushedJSValue,
  47     ConflictingFlush
  48 };
  49
  50 inline NodeFlags resultFor(FlushFormat format)
  51 {
  52     switch (format) {
  53     case DeadFlush:
  54     case FlushedJSValue:
  55     case FlushedCell:
  56     case ConflictingFlush:
  57         return NodeResultJS;
  58     case FlushedInt32:
  59         return NodeResultInt32;
  60     case FlushedInt52:
  61         return NodeResultInt52;
  62     case FlushedDouble:
  63         return NodeResultDouble;
  64     case FlushedBoolean:
  65         return NodeResultBoolean;
  66     }
  67     RELEASE_ASSERT_NOT_REACHED();
  68     return 0;
  69 }
  70
  71 inline UseKind useKindFor(FlushFormat format)
  72 {
  73     switch (format) {
  74     case DeadFlush:
  75     case FlushedJSValue:
  76     case ConflictingFlush:
  77         return UntypedUse;
  78     case FlushedCell:
  79         return CellUse;
  80     case FlushedInt32:
  81         return Int32Use;
  82     case FlushedInt52:
  83         return Int52RepUse;
  84     case FlushedDouble:
  85         return DoubleRepUse;
  86     case FlushedBoolean:
  87         return BooleanUse;
  88     }
  89     RELEASE_ASSERT_NOT_REACHED();
  90     return UntypedUse;
  91 }
  92
  93 inline SpeculatedType typeFilterFor(FlushFormat format)
  94 {
  95     return typeFilterFor(useKindFor(format));
  96 }
  97
  98 inline DataFormat dataFormatFor(FlushFormat format)
  99 {
 100     switch (format) {
 101     case DeadFlush:
 102     case ConflictingFlush:
 103         return DataFormatDead;
 104     case FlushedJSValue:
 105         return DataFormatJS;
 106     case FlushedDouble:
 107         return DataFormatDouble;
 108     case FlushedInt32:
 109         return DataFormatInt32;
 110     case FlushedInt52:
 111         return DataFormatInt52;
 112     case FlushedCell:
 113         return DataFormatCell;
 114     case FlushedBoolean:
 115         return DataFormatBoolean;
 116     }
 117     RELEASE_ASSERT_NOT_REACHED();
 118     return DataFormatDead;
 119 }
 120
 121 inline FlushFormat merge(FlushFormat a, FlushFormat b)
 122 {
 123     if (a == DeadFlush)
 124         return b;
 125     if (b == DeadFlush)
 126         return a;
 127     if (a == b)
 128         return a;
 129     return ConflictingFlush;
 130 }
 131
 132 inline bool isConcrete(FlushFormat format)
 133 {
 134     return format != DeadFlush && format != ConflictingFlush;
 135 }
 136
 137 } } // namespace JSC::DFG
 138
 139 namespace WTF {
 140
 141 void printInternal(PrintStream&, JSC::DFG::FlushFormat);
 142
 143 inline JSC::DFG::FlushFormat inContext(JSC::DFG::FlushFormat format, JSC::DumpContext*)
 144 {
 145     return format;
 146 }
 147
 148 } // namespace WTF
 149
 150 #endif // ENABLE(DFG_JIT)
 151
 152 #endif // DFGFlushFormat_h
 153