[RS4GC] Add a GCStrategy option to enable RS4GC

[znix]

Summary

Currently, the RewriteStatepointsForGC pass has a hardcoded list of GC
strategies that it operates on, forcing downstream projects to patch
LLVM to enable it for their own strategies. The diff D141110 changes
that to each GCStrategy having a flag to enable or disable RS4GC.

This patch adds that flag. It currently doesn't do anything, but is
provided so downstream projects can enable it to smooth the transition.

[dantrushin]

LGTM after assertion fix.
I'll take care of landing

llvm/include/llvm/IR/GCStrategy.h

108–110

Assert should go before return :-)

llvm/include/llvm/IR/GCStrategy.h

 class GCStrategy {
 private:
   friend class GCModuleInfo;
 
   std::string Name;
 
 protected:
   bool UseStatepoints = false; /// Uses gc.statepoints as opposed to gc.roots,
-                               /// if set, none of the other options can be
-                               /// anything but their default values.
+                               /// if set, NeededSafePoints and UsesMetadata
+                               /// should be left at their default values.
+
+  bool UseRS4GC = false; /// If UseStatepoints is set, this determines whether
+                         /// the RewriteStatepointsForGC pass should rewrite
+                         /// this function's calls.
+                         /// This should only be set if UseStatepoints is set.
 
   bool NeededSafePoints = false;    ///< if set, calls are inferred to be safepoints
   bool UsesMetadata = false;     ///< If set, backend must emit metadata tables.
 
 public:
   GCStrategy();
   virtual ~GCStrategy() = default;
 
public:
 
   /// If the type specified can be reliably distinguished, returns true for
   /// pointers to GC managed locations and false for pointers to non-GC
   /// managed locations.  Note a GCStrategy can always return 'std::nullopt'
   /// (i.e. an empty optional indicating it can't reliably distinguish.
   virtual std::optional<bool> isGCManagedPointer(const Type *Ty) const {
     return std::nullopt;
   }
+
+  /// Returns true if the RewriteStatepointsForGC pass should run on functions
+  /// using this GC.
+  bool useRS4GC() const {
+    assert(useStatepoints() &&
+           "GC strategy has useRS4GC but not useStatepoints set");
+    return UseRS4GC;
+  }
+
   ///@}
 
   /// If set, appropriate metadata tables must be emitted by the back-end
   /// (assembler, JIT, or otherwise). The default stackmap information can be
   /// found in the StackMap section as described in the documentation.
   bool usesMetadata() const { return UsesMetadata; }
 
   /** @name GCRoot Specific Properties

llvm/lib/IR/BuiltinGCs.cpp

 /// implementation usable with any collector which can consume the standard
 /// stackmap format generated by statepoints, uses the default addrespace to
 /// distinguish between gc managed and non-gc managed pointers, and has
 /// reasonable relocation semantics.
 class StatepointGC : public GCStrategy {
 public:
   StatepointGC() {
     UseStatepoints = true;
+    UseRS4GC = true;
     // These options are all gc.root specific, we specify them so that the
     // gc.root lowering code doesn't run.
     NeededSafePoints = false;
     UsesMetadata = false;
   }
 
   std::optional<bool> isGCManagedPointer(const Type *Ty) const override {
     // Method is only valid on pointer typed values.

 ///    edges and before tail-calls (not needed at function-entry)
 ///
 /// The above differences in behavior are to be implemented in upcoming
 /// checkins.
 class CoreCLRGC : public GCStrategy {
 public:
   CoreCLRGC() {
     UseStatepoints = true;
+    UseRS4GC = true;
     // These options are all gc.root specific, we specify them so that the
     // gc.root lowering code doesn't run.
     NeededSafePoints = false;
     UsesMetadata = false;
   }
 
   std::optional<bool> isGCManagedPointer(const Type *Ty) const override {
     // Method is only valid on pointer typed values.