1 //===- PlaceSafepoints.h - Place GC Safepoints ----------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Place garbage collection safepoints at appropriate locations in the IR. This 10 // does not make relocation semantics or variable liveness explicit. That's 11 // done by RewriteStatepointsForGC. 12 // 13 // Terminology: 14 // - A call is said to be "parseable" if there is a stack map generated for the 15 // return PC of the call. A runtime can determine where values listed in the 16 // deopt arguments and (after RewriteStatepointsForGC) gc arguments are located 17 // on the stack when the code is suspended inside such a call. Every parse 18 // point is represented by a call wrapped in an gc.statepoint intrinsic. 19 // - A "poll" is an explicit check in the generated code to determine if the 20 // runtime needs the generated code to cooperate by calling a helper routine 21 // and thus suspending its execution at a known state. The call to the helper 22 // routine will be parseable. The (gc & runtime specific) logic of a poll is 23 // assumed to be provided in a function of the name "gc.safepoint_poll". 24 // 25 // We aim to insert polls such that running code can quickly be brought to a 26 // well defined state for inspection by the collector. In the current 27 // implementation, this is done via the insertion of poll sites at method entry 28 // and the backedge of most loops. We try to avoid inserting more polls than 29 // are necessary to ensure a finite period between poll sites. This is not 30 // because the poll itself is expensive in the generated code; it's not. Polls 31 // do tend to impact the optimizer itself in negative ways; we'd like to avoid 32 // perturbing the optimization of the method as much as we can. 33 // 34 // We also need to make most call sites parseable. The callee might execute a 35 // poll (or otherwise be inspected by the GC). If so, the entire stack 36 // (including the suspended frame of the current method) must be parseable. 37 // 38 // This pass will insert: 39 // - Call parse points ("call safepoints") for any call which may need to 40 // reach a safepoint during the execution of the callee function. 41 // - Backedge safepoint polls and entry safepoint polls to ensure that 42 // executing code reaches a safepoint poll in a finite amount of time. 43 // 44 // We do not currently support return statepoints, but adding them would not 45 // be hard. They are not required for correctness - entry safepoints are an 46 // alternative - but some GCs may prefer them. Patches welcome. 47 // 48 //===----------------------------------------------------------------------===// 49 50 #ifndef LLVM_TRANSFORMS_SCALAR_PLACESAFEPOINTS_H 51 #define LLVM_TRANSFORMS_SCALAR_PLACESAFEPOINTS_H 52 53 #include "llvm/IR/PassManager.h" 54 55 namespace llvm { 56 57 class TargetLibraryInfo; 58 59 class PlaceSafepointsPass : public PassInfoMixin<PlaceSafepointsPass> { 60 public: 61 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 62 63 bool runImpl(Function &F, const TargetLibraryInfo &TLI); 64 65 void cleanup() {} 66 67 private: 68 }; 69 } // namespace llvm 70 71 #endif // LLVM_TRANSFORMS_SCALAR_PLACESAFEPOINTS_H 72