Lines Matching defs:live
103 static cl::opt<bool, true> ClobberNonLiveOverride("rs4gc-clobber-non-live",
171 /// Values used in this block (and thus live); does not included values
175 /// Values live into this basic block (i.e. used by any
179 /// Values live out of this basic block (i.e. live into
202 /// The set of values known to be live across this safepoint
213 /// Record live values we are rematerialized instead of relocating.
244 /// Compute the live-in set for every basic block in the function
248 /// Given results from the dataflow liveness computation, find the set of live
264 // pointer and b) is of a type this code expects to encounter as a live value.
310 // Conservatively identifies any definitions which might be live at the
313 // live. Values used by that instruction are considered live.
327 dbgs() << "Number live values: " << LiveSet.size() << "\n";
472 // live. Besides global references, all kinds of constants (e.g. undef,
976 // Even though we have identified a concrete base (or a conflict) for all live
1293 // For a set of live pointers (base and/or derived), identify the base
1295 // mutate the IR graph as needed to make the 'base' pointer live at the
1300 // preconditions: live is a set of pointer type Values
1306 // pointer in live. Note that derived can be equal to base if the original
1308 static void findBasePointers(const StatepointLiveSetTy &live,
1312 for (Value *ptr : live) {
1323 /// Find the required based pointers (and adjust the live set) for the given
1360 // again. The old values are still live and will help it stabilize quickly.
1411 // live set. They have been proved to be the same PHI nodes. Note
1644 return "live-through";
1692 // Pass through the requested lowering if any. The default is live-through.
1694 if (DeoptLowering == "live-in")
1697 assert(DeoptLowering == "live-through" && "Unsupported value!");
1917 // live set of some other safepoint, in which case that safepoint's
1920 // after the live sets have been made explicit in the IR, and we no longer
1931 // Second, create a gc.relocate for every live variable
1938 // WARNING: Does not do any fixup to adjust users of the original live
2048 // Emit alloca for each live gc pointer
2225 /// Insert holders so that each Value is obviously live through the entire
2230 // No values to hold live, might as well not insert the empty holder
2234 // Use a dummy vararg function to actually hold the values live
2370 // For each live pointer find its defining chain.
2416 // (instead of rematerializing after every statepoint it is live through).
2417 // This can be beneficial when derived pointer is live across many
2456 // of statepoints it is live through.
2463 LLVM_DEBUG(dbgs() << "Num uses: " << NumUses << " Num live statepoints: "
2472 // uses as it generally shortens live ranges.
2496 // know exaclty in what BBs it is still live.
2536 // From the statepoint live set pick values that are cheaper to recompute then
2537 // to relocate. Remove this values from the live set, rematerialize them after
2545 // Record values we are going to delete from this statepoint live set.
2566 // Remove value from the live set
2600 // Remove rematerialized values from the live set.
2684 // live in the IR. We'll remove all of these when done.
2689 // in the deopt argument list are considered live through the safepoint (and
2706 // A) Identify all gc pointers which are statically live at the given call
2710 /// Global mapping from live pointers to a base-defining-value.
2713 // B) Find the base pointers for each live pointer
2731 // instructions which are now live at some safepoint. The simplest such
2735 // safepoint 1 <-- that needs to be live here
2739 // We insert some dummy calls after each safepoint to definitely hold live
2741 // ask liveness for _every_ base inserted to see what is now live. Then we
2772 // It is possible that non-constant live variables have a constant base. For
2796 // In order to reduce live set of statepoint we might choose to rematerialize
2807 // may themselves be live over a statepoint. For details, please see usage in
2812 // the live variables listed. We do not yet update uses of the values being
2813 // relocated. We have references to live variables that need to
2815 // previous statepoint can not be a live variable, thus we can and remove
2829 // These live sets may contain state Value pointers, since we replaced calls
2831 // those calls may have been def'ing live gc pointers. Clear these out to
2835 // these live sets, and migrate to using that data structure from this point
2841 // Do all the fixups of the original live variables to their relocated selves
2844 // We can't simply save the live set from the original insertion. One of
2845 // the live values might be the result of a call which needs a safepoint.
2847 // Thankfully, the live set is embedded in the statepoint (and updated), so
2863 "unreachable values should never be live");
3117 // Note: This may extend the live range of the inputs to the icmp and thus
3120 // lowering for live values this would be a much safer transform.
3178 // live references.
3194 /// Compute the live-in set for the location rbegin starting from
3195 /// the live-out set of the basic block
3295 assert(!Data.LiveSet[&BB].count(Kill) && "live set contains kill");
3359 // call result is not live (normal), nor are it's arguments
3376 // We may have base pointers which are now live that weren't before. We need