Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Roblox
GitHub Repository: Roblox/luau
 Path: blob/master/CodeGen/include/Luau/ConditionX64.h
2727 views
1
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details

2
#pragma once

3


4
#include "Luau/CodeGenCommon.h"

5


6
namespace Luau

7
{

8
namespace CodeGen

9
{

10


11
enum class ConditionX64 : uint8_t

12
{

13
    Overflow,

14
    NoOverflow,

15


16
    Carry,

17
    NoCarry,

18


19
    Below,

20
    BelowEqual,

21
    Above,

22
    AboveEqual,

23
    Equal,

24
    Less,

25
    LessEqual,

26
    Greater,

27
    GreaterEqual,

28


29
    NotBelow,

30
    NotBelowEqual,

31
    NotAbove,

32
    NotAboveEqual,

33
    NotEqual,

34
    NotLess,

35
    NotLessEqual,

36
    NotGreater,

37
    NotGreaterEqual,

38


39
    Zero,

40
    NotZero,

41


42
    Parity,

43
    NotParity,

44


45
    Count

46
};

47


48
// Returns a condition that for 'a op b' will result in '!(a op b)'

49
inline ConditionX64 getNegatedCondition(ConditionX64 cond)

50
{

51
    switch (cond)

52
    {

53
    case ConditionX64::Overflow:

54
        return ConditionX64::NoOverflow;

55
    case ConditionX64::NoOverflow:

56
        return ConditionX64::Overflow;

57
    case ConditionX64::Carry:

58
        return ConditionX64::NoCarry;

59
    case ConditionX64::NoCarry:

60
        return ConditionX64::Carry;

61
    case ConditionX64::Below:

62
        return ConditionX64::NotBelow;

63
    case ConditionX64::BelowEqual:

64
        return ConditionX64::NotBelowEqual;

65
    case ConditionX64::Above:

66
        return ConditionX64::NotAbove;

67
    case ConditionX64::AboveEqual:

68
        return ConditionX64::NotAboveEqual;

69
    case ConditionX64::Equal:

70
        return ConditionX64::NotEqual;

71
    case ConditionX64::Less:

72
        return ConditionX64::NotLess;

73
    case ConditionX64::LessEqual:

74
        return ConditionX64::NotLessEqual;

75
    case ConditionX64::Greater:

76
        return ConditionX64::NotGreater;

77
    case ConditionX64::GreaterEqual:

78
        return ConditionX64::NotGreaterEqual;

79
    case ConditionX64::NotBelow:

80
        return ConditionX64::Below;

81
    case ConditionX64::NotBelowEqual:

82
        return ConditionX64::BelowEqual;

83
    case ConditionX64::NotAbove:

84
        return ConditionX64::Above;

85
    case ConditionX64::NotAboveEqual:

86
        return ConditionX64::AboveEqual;

87
    case ConditionX64::NotEqual:

88
        return ConditionX64::Equal;

89
    case ConditionX64::NotLess:

90
        return ConditionX64::Less;

91
    case ConditionX64::NotLessEqual:

92
        return ConditionX64::LessEqual;

93
    case ConditionX64::NotGreater:

94
        return ConditionX64::Greater;

95
    case ConditionX64::NotGreaterEqual:

96
        return ConditionX64::GreaterEqual;

97
    case ConditionX64::Zero:

98
        return ConditionX64::NotZero;

99
    case ConditionX64::NotZero:

100
        return ConditionX64::Zero;

101
    case ConditionX64::Parity:

102
        return ConditionX64::NotParity;

103
    case ConditionX64::NotParity:

104
        return ConditionX64::Parity;

105
    case ConditionX64::Count:

106
        CODEGEN_ASSERT(!"invalid ConditionX64 value");

107
    }

108


109
    return ConditionX64::Count;

110
}

111


112
// Returns a condition that for 'a op b' will result in 'b op a'

113
// Only a subset of conditions is allowed

114
inline ConditionX64 getInverseCondition(ConditionX64 cond)

115
{

116
    switch (cond)

117
    {

118
    case ConditionX64::Below:

119
        return ConditionX64::Above;

120
    case ConditionX64::BelowEqual:

121
        return ConditionX64::AboveEqual;

122
    case ConditionX64::Above:

123
        return ConditionX64::Below;

124
    case ConditionX64::AboveEqual:

125
        return ConditionX64::BelowEqual;

126
    case ConditionX64::Equal:

127
        return ConditionX64::Equal;

128
    case ConditionX64::Less:

129
        return ConditionX64::Greater;

130
    case ConditionX64::LessEqual:

131
        return ConditionX64::GreaterEqual;

132
    case ConditionX64::Greater:

133
        return ConditionX64::Less;

134
    case ConditionX64::GreaterEqual:

135
        return ConditionX64::LessEqual;

136
    case ConditionX64::NotBelow:

137
        return ConditionX64::NotAbove;

138
    case ConditionX64::NotBelowEqual:

139
        return ConditionX64::NotAboveEqual;

140
    case ConditionX64::NotAbove:

141
        return ConditionX64::NotBelow;

142
    case ConditionX64::NotAboveEqual:

143
        return ConditionX64::NotBelowEqual;

144
    case ConditionX64::NotEqual:

145
        return ConditionX64::NotEqual;

146
    case ConditionX64::NotLess:

147
        return ConditionX64::NotGreater;

148
    case ConditionX64::NotLessEqual:

149
        return ConditionX64::NotGreaterEqual;

150
    case ConditionX64::NotGreater:

151
        return ConditionX64::NotLess;

152
    case ConditionX64::NotGreaterEqual:

153
        return ConditionX64::NotLessEqual;

154
    default:

155
        CODEGEN_ASSERT(!"invalid ConditionX64 value for getInverseCondition");

156
    }

157


158
    return ConditionX64::Count;

159
}

160


161
} // namespace CodeGen

162
} // namespace Luau

163


164