Lines Matching defs:Statepoint
35 #include "llvm/IR/Statepoint.h"
75 AllowStatepointWithNoDeoptInfo("rs4gc-allow-statepoint-with-no-deopt-info",
111 /// RewriteStatepointsForGC runs, all calls to gc.statepoint "free" the entire
115 /// Similar reasoning also applies to the noalias attributes. gc.statepoint
177 /// The *new* gc.statepoint instruction itself. This produces the token
1079 // no uses of the original value / return value between the gc.statepoint and
1082 // gc.relocates only on the path which goes through the statepoint. We might
1121 // These attributes control the generation of the gc.statepoint call /
1122 // invoke itself; and once the gc.statepoint is in place, they're of no
1140 /// statepoint.
1145 /// statepointToken - statepoint instruction to which relocates should be
1341 // Create the statepoint given all the arguments
1357 // directly on statepoint and return attrs later for gc_result intrinsic.
1385 // directly on statepoint and return attrs later for gc_result intrinsic.
1404 const unsigned LiveStartIdx = Statepoint(Token).gcArgsStartIdx();
1417 // statepoint
1422 // If we're wrapping an @llvm.experimental.deoptimize in a statepoint, we
1452 const unsigned LiveStartIdx = Statepoint(Token).gcArgsStartIdx();
1456 // Replace an existing gc.statepoint with a new one and a set of gc.relocates
1480 // Do the actual rewriting and delete the old statepoint
1486 // It receives iterator to the statepoint gc relocates and emits a store to the
1597 // Update gc pointer after each statepoint: either store a relocated value or
1599 // gc_result). This must happen before we update the statepoint with load of
1600 // alloca otherwise we lose the link between statepoint and old def.
1602 Value *Statepoint = Info.StatepointToken;
1607 // Insert stores for normal statepoint gc relocates
1608 insertRelocationStores(Statepoint->users(), AllocaMap, VisitedLiveValues);
1610 // In case if it was invoke statepoint
1612 Statepoint)) {
1623 // the gc.statepoint. This will turn some subtle GC problems into
1650 if (auto II = dyn_cast<InvokeInst>(Statepoint)) {
1654 InsertClobbersAt(cast<Instruction>(Statepoint)->getNextNode());
1855 // From the statepoint live set pick values that are cheaper to recompute then
1857 // statepoint and record them in "Info" structure. Note that similar to
1864 // Record values we are going to delete from this statepoint live set.
1887 // don't have any uses besides this statepoint.
1908 // which should be used after statepoint.
1916 // otherwise not used after this statepoint.
2102 // In order to reduce live set of statepoint we might choose to rematerialize
2109 // may themselves be live over a statepoint. For details, please see usage in
2117 // previous statepoint can not be a live variable, thus we can and remove
2118 // the old statepoint calls as we go.)
2131 // with operand bundles with calls wrapped in gc.statepoint, and some of
2150 // Thankfully, the live set is embedded in the statepoint (and updated), so
2152 Statepoint Statepoint(Info.StatepointToken);
2153 Live.insert(Live.end(), Statepoint.gc_args_begin(),
2154 Statepoint.gc_args_end());
2161 "statepoint must be reachable or liveness is meaningless");
2162 for (Value *V : Statepoint.gc_args()) {
2261 const StringRef StatepointExampleName("statepoint-example");
2350 // increase the liveset of any statepoint we move over. This is profitable
2545 // We want to handle the statepoint itself oddly. It's
