git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

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 */

26 #include "config.h"

27 #include "FTLExitValue.h"

29 #if ENABLE(FTL_JIT)

31 #include "FTLExitTimeObjectMaterialization.h"

32 #include "JSCInlines.h"

33 #include "TrackedReferences.h"

35 namespace JSC { namespace FTL {

 ExitValue ExitValue::materializeNewObject(ExitTimeObjectMaterialization* data)

38 {

39 ExitValue result;

40 result.m_kind = ExitValueMaterializeNewObject;

41 result.u.newObjectMaterializationData = data;

42 return result;

43 }

 ExitValue ExitValue::withLocalsOffset(int offset) const

46 {

47 if (!isInJSStackSomehow())

48 return *this;

     if (!virtualRegister().isLocal())

50 return *this;

     return withVirtualRegister(virtualRegister() + offset);

52 }

 ValueFormat ExitValue::valueFormat() const

55 {

56 switch (kind()) {

57 case InvalidExitValue:

58 RELEASE_ASSERT_NOT_REACHED();

59 return InvalidValueFormat;

61 case ExitValueDead:

62 case ExitValueConstant:

63 case ExitValueInJSStack:

64 case ExitValueMaterializeNewObject:

65 return ValueFormatJSValue;

67 case ExitValueArgument:

         return exitArgument().format();

70 case ExitValueInJSStackAsInt32:

71 return ValueFormatInt32;

73 case ExitValueInJSStackAsInt52:

74 return ValueFormatInt52;

76 case ExitValueInJSStackAsDouble:

77 return ValueFormatDouble;

79 case ExitValueRecovery:

80 return recoveryFormat();

81 }

83 RELEASE_ASSERT_NOT_REACHED();

84 return InvalidValueFormat;

85 }

 void ExitValue::dumpInContext(PrintStream& out, DumpContext* context) const

88 {

89 switch (kind()) {

90 case InvalidExitValue:

         out.print("Invalid");

92 return;

93 case ExitValueDead:

         out.print("Dead");

95 return;

96 case ExitValueArgument:

         out.print("Argument(", exitArgument(), ")");

98 return;

99 case ExitValueConstant:

         out.print("Constant(", inContext(constant(), context), ")");

101 return;

102 case ExitValueInJSStack:

         out.print("InJSStack:", virtualRegister());

104 return;

105 case ExitValueInJSStackAsInt32:

         out.print("InJSStackAsInt32:", virtualRegister());

107 return;

108 case ExitValueInJSStackAsInt52:

         out.print("InJSStackAsInt52:", virtualRegister());

110 return;

111 case ExitValueInJSStackAsDouble:

         out.print("InJSStackAsDouble:", virtualRegister());

113 return;

114 case ExitValueRecovery:

         out.print("Recovery(", recoveryOpcode(), ", arg", leftRecoveryArgument(), ", arg", rightRecoveryArgument(), ", ", recoveryFormat(), ")");

116 return;

117 case ExitValueMaterializeNewObject:

         out.print("Materialize(", WTF::RawPointer(objectMaterialization()), ")");

119 return;

120 }

121

122 RELEASE_ASSERT_NOT_REACHED();

123 }

124

 void ExitValue::dump(PrintStream& out) const

126 {

     dumpInContext(out, 0);

128 }

129

 void ExitValue::validateReferences(const TrackedReferences& trackedReferences) const

131 {

132 if (isConstant())

         trackedReferences.check(constant());

134 }

135

136 } } // namespace JSC::FTL

137

138 #endif // ENABLE(FTL_JIT)

139