WebKit/Source/JavaScriptCore/b3/B3Effects.h at main · WebKit/WebKit · GitHub

History

166 lines (137 loc) · 6.79 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

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

#pragma once

#if ENABLE(B3_JIT)

#include "B3HeapRange.h"

#include <wtf/PrintStream.h>

namespace JSC { namespace B3 {

enum class Mutability : uint8_t {

Mutable,

Immutable,

};

struct Effects {

// True if this cannot continue execution in the current block.

bool terminal : 1 { false };

// True if this value can cause execution to terminate abruptly, and that this abrupt termination is

// observable. An example of how this gets used is to limit the hoisting of controlDependent values.

// Note that if exitsSideways is set to true but reads is bottom, then B3 is free to assume that

// after abrupt termination of this procedure, none of the heap will be read. That's usually false,

// so make sure that reads corresponds to the set of things that are readable after this function

// terminates abruptly.

bool exitsSideways : 1 { false };

// True if the instruction may change semantics if hoisted above some control flow. For example,

// loads are usually control-dependent because we must assume that any control construct (either

// a terminal like Branch or anything that exits sideways, like Check) validates whether the

// pointer is valid. Hoisting the load above control may cause the load to trap even though it

// would not have otherwise trapped.

bool controlDependent : 1 { false };

// Mutability::Immutable if the instruction is readings an immutable value. This read itself can

// be control dependent, but once it succeeds, the subsequent code must be producing the same value.

// CSE leverages this information and eliminate redundant loads when the target and preceding load

// are the same and Mutability::Immutable.

Mutability readsMutability : 1 { Mutability::Mutable };

// True if this writes to the local state. Operations that write local state don't write to anything

// in "memory" but they have a side-effect anyway. This is for modeling Upsilons, Sets, and Fences.

// This is a way of saying: even though this operation is not a terminal, does not exit sideways,

// and does not write to the heap, you still cannot kill this operation.

bool writesLocalState : 1 { false };

// True if this reads from the local state. This is only used for Phi and Get.

bool readsLocalState : 1 { false };

// B3 understands things about pinned registers. Therefore, it needs to know who reads them and

// who writes them. We don't track this on a per-register basis because that would be harder and

// we don't need it. Note that if you want to construct an immutable pinned register while also

// having other pinned registers that are mutable, then you can use ArgumentReg. Also note that

// nobody will stop you from making this get out-of-sync with your clobbered register sets in

// Patchpoint. It's recommended that you err on the side of being conservative.

// FIXME: Explore making these be RegisterSets. That's mainly hard because it would be awkward to

// reconcile with StackmapValue's support for clobbered regs.

// https://bugs.webkit.org/show_bug.cgi?id=163173

bool readsPinned : 1 { false };

bool writesPinned : 1 { false };

// Memory fences cannot be reordered around each other regardless of their effects. This is flagged

// if the operation is a memory fence.

bool fence : 1 { false };

private:

// Sentinel for the constant-effects table in B3ValueInlines.h: marks opcodes whose effects are

// value-dependent. Never set on Effects describing an actual value. Declared adjacent to the

// bitfields above so it packs into the same allocation unit (no size growth).

bool m_invalid : 1 { false };

public:

// WARNING: The B3::hoistLoopInvariantValues() phase thinks that it understands this exhaustively. If you

// add any new kinds of things that can be read or written, you should check that phase.

HeapRange writes;

HeapRange reads;

static constexpr Effects none()

{

return Effects();

}

static constexpr Effects invalid()

{

Effects result;

result.m_invalid = true;

return result;

}

constexpr bool isValid() const { return !m_invalid; }

constexpr bool isInvalid() const { return m_invalid; }

static constexpr Effects forCall()

{

Effects result;

result.exitsSideways = true;

result.controlDependent = true;

result.writes = HeapRange::top();

result.reads = HeapRange::top();

result.readsPinned = true;

result.writesPinned = true;

result.fence = true;

return result;

}

static constexpr Effects forCheck()

{

Effects result;

result.exitsSideways = true;

// The program could read anything after exiting, and it's on us to declare this.

result.reads = HeapRange::top();

return result;

}

constexpr bool isWrite() const

{

return writesLocalState || writes || writesPinned || fence;

}

constexpr bool isTrapBarrier() const

{

return exitsSideways || isWrite();

}

constexpr bool mustExecute() const

{

return terminal || isTrapBarrier();

}

// Returns true if reordering instructions with these respective effects would change program

// behavior in an observable way.

bool NODELETE interferes(const Effects&) const;

friend bool operator==(const Effects&, const Effects&) = default;

JS_EXPORT_PRIVATE void dump(PrintStream& out) const;

};

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)

WebKit/Source/JavaScriptCore/b3/B3Effects.h at main · WebKit/WebKit · GitHub

Uh oh!

Expand file tree

Breadcrumbs

B3Effects.h

Latest commit

History

Breadcrumbs

B3Effects.h

File metadata and controls