[deref] Ask GC if it can free memory at a pointer

[mkazantsev]

Summary

This patch replaces copy-pastish and non-genetic check in deref in presence
of GC with a query to the GC. Should be NFC w.r.t. current behavior, but better
structured code.

[mkazantsev]

Puttin "planned changes" until underlying patches have been merged.

llvm/include/llvm/CodeGen/LinkAllCodegenComponents.h

 //===- llvm/Codegen/LinkAllCodegenComponents.h ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This header file pulls in all codegen related passes for tools like lli and
 // llc that need this functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_LINKALLCODEGENCOMPONENTS_H
 #define LLVM_CODEGEN_LINKALLCODEGENCOMPONENTS_H
 
-#include "llvm/IR/BuiltinGCs.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/SchedulerRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 #include <cstdlib>
 
 namespace {
   struct ForceCodegenLinking {
     ForceCodegenLinking() {
       // We must reference the passes in such a way that compilers will not
       // delete it all as dead code, even with whole program optimization,
       // yet is effectively a NO-OP. As the compiler isn't smart enough
       // to know that getenv() never returns -1, this will do the job.
       if (std::getenv("bar") != (char*) -1)
         return;
 
       (void) llvm::createFastRegisterAllocator();
       (void) llvm::createBasicRegisterAllocator();
       (void) llvm::createGreedyRegisterAllocator();
       (void) llvm::createDefaultPBQPRegisterAllocator();
 
-      llvm::linkAllBuiltinGCs();
-
       (void) llvm::createBURRListDAGScheduler(nullptr,
                                               llvm::CodeGenOpt::Default);
       (void) llvm::createSourceListDAGScheduler(nullptr,
                                                 llvm::CodeGenOpt::Default);
       (void) llvm::createHybridListDAGScheduler(nullptr,
                                                 llvm::CodeGenOpt::Default);
       (void) llvm::createFastDAGScheduler(nullptr, llvm::CodeGenOpt::Default);
       (void) llvm::createDefaultScheduler(nullptr, llvm::CodeGenOpt::Default);
       (void) llvm::createVLIWDAGScheduler(nullptr, llvm::CodeGenOpt::Default);
 
     }
   } ForceCodegenLinking; // Force link by creating a global definition.
 }
 
 #endif

llvm/include/llvm/IR/GCStrategy.h

 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Registry.h"
 #include <string>
 
 namespace llvm {
 
 class Type;
+class Value;
 
 /// GCStrategy describes a garbage collector algorithm's code generation
 /// requirements, and provides overridable hooks for those needs which cannot
 /// be abstractly described.  GCStrategy objects must be looked up through
 /// the Function.  The objects themselves are owned by the Context and must
 /// be immutable.
 class GCStrategy {
 private:
public:
   /// pointers to GC managed locations and false for pointers to non-GC
   /// managed locations.  Note a GCStrategy can always return 'None' (i.e. an
   /// empty optional indicating it can't reliably distinguish.
   virtual Optional<bool> isGCManagedPointer(const Type *Ty) const {
     return None;
   }
   ///@}
 
+  /// Return true if Value is a pointer can be freed in this GC strategy.
+  /// Returns true if this value can be freed. Returns false if V can never
+  /// be freed. Note a GCStrategy can always return 'None' (i.e. an empty
+  /// optional indicating it can't reliably distinguish).
+  virtual Optional<bool> canBeFreed(const Value *V) const { return None; }
+
   /** @name GCRoot Specific Properties
    * These properties and overrides only apply to collector strategies using
    * GCRoot.
    */
   ///@{
 
   /// True if safe points need to be inferred on call sites
   bool needsSafePoints() const { return NeededSafePoints; }

llvm/lib/IR/BuiltinGCs.cpp

 //===- BuiltinGCs.cpp - Boilerplate for our built in GC types -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the boilerplate required to define our various built in
 // gc lowering strategies.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/BuiltinGCs.h"
 #include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Statepoint.h"
+#include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 namespace {
 
 /// An example GC which attempts to be compatibile with Erlang/OTP garbage
 /// collector.
Optional<bool> isGCManagedPointer(const Type *Ty) const override {
     const PointerType *PT = cast<PointerType>(Ty);
     // For the sake of this example GC, we arbitrarily pick addrspace(1) as our
     // GC managed heap.  We know that a pointer into this heap needs to be
     // updated and that no other pointer does.  Note that addrspace(1) is used
     // only as an example, it has no special meaning, and is not reserved for
     // GC usage.
     return (1 == PT->getAddressSpace());
   }
+
+  virtual Optional<bool> canBeFreed(const Value *V) const override {
+    if (!*isGCManagedPointer(V->getType()))
+      return None;
+
+    const Module *M = nullptr;
+    if (auto *I = dyn_cast<Instruction>(V))
+      M = I->getModule();
+    else if (auto *A = dyn_cast<Argument>(V))
+      M = A->getParent()->getParent();
+    else
+      return None;
+
+    // It is cheaper to scan for a declaration than to scan for a use in this
+    // function.  Note that gc.statepoint is a type overloaded function so the
+    // usual trick of requesting declaration of the intrinsic from the module
+    // doesn't work.
+    for (auto &Fn : *M)
+      if (Fn.getIntrinsicID() == Intrinsic::experimental_gc_statepoint)
+        return true;
+
+    return false;
+  }
 };
 
 /// A GCStrategy for the CoreCLR Runtime. The strategy is similar to
 /// Statepoint-example GC, but differs from it in certain aspects, such as:
 /// 1) Base-pointers need not be explicitly tracked and reported for
 ///    interior pointers
 /// 2) Uses a different format for encoding stack-maps
 /// 3) Location of Safe-point polls: polls are only needed before loop-back

llvm/lib/IR/GCStrategy.cpp

 //===- GCStrategy.cpp - Garbage Collector Description ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the policy object GCStrategy which describes the
 // behavior of a given garbage collector.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/GCStrategy.h"
+#include "llvm/IR/BuiltinGCs.h"
 
 using namespace llvm;
 
 LLVM_INSTANTIATE_REGISTRY(GCRegistry)
 
 GCStrategy::GCStrategy() = default;
 
 std::unique_ptr<GCStrategy> llvm::getGCStrategy(const StringRef Name) {
   for (auto &S : GCRegistry::entries())
     if (S.getName() == Name)
       return S.instantiate();
 
   if (GCRegistry::begin() == GCRegistry::end()) {
     // In normal operation, the registry should not be empty.  There should
     // be the builtin GCs if nothing else.  The most likely scenario here is
     // that we got here without running the initializers used by the Registry
     // itself and it's registration mechanism.
     const std::string error =
         std::string("unsupported GC: ") + Name.str() +
         " (did you remember to link and initialize the library?)";
     report_fatal_error(error);
   } else
     report_fatal_error(std::string("unsupported GC: ") + Name.str());
 }
+
+struct ForceGCLinking {
+  ForceGCLinking() { llvm::linkAllBuiltinGCs(); }
+} ForceGCLinking; // Force link by creating a global definition.

llvm/lib/IR/Value.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DerivedUser.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/ValueSymbolTable.h"
bool Value::canBeFreed() const {
   // With garbage collection, deallocation typically occurs solely at or after
   // safepoints.  If we're compiling for a collector which uses the
   // gc.statepoint infrastructure, safepoints aren't explicitly present
   // in the IR until after lowering from abstract to physical machine model.
   // The collector could chose to mix explicit deallocation and gc'd objects
   // which is why we need the explicit opt in on a per collector basis.
   if (!F->hasGC())
     return true;
-  
-  const auto &GCName = F->getGC();
-  const StringRef StatepointExampleName("statepoint-example");
-  if (GCName != StatepointExampleName)
-    return true;
-
-  auto *PT = cast<PointerType>(this->getType());
-  if (PT->getAddressSpace() != 1)
-    // For the sake of this example GC, we arbitrarily pick addrspace(1) as our
-    // GC managed heap.  This must match the same check in
-    // RewriteStatepointsForGC (and probably needs better factored.)
-    return true;
-
-  // It is cheaper to scan for a declaration than to scan for a use in this
-  // function.  Note that gc.statepoint is a type overloaded function so the
-  // usual trick of requesting declaration of the intrinsic from the module
-  // doesn't work.
-  for (auto &Fn : *F->getParent())
-    if (Fn.getIntrinsicID() == Intrinsic::experimental_gc_statepoint)
-      return true;
-  return false;
+  auto GCStrategy = getGCStrategy(F->getGC());
+  Optional<bool> CanBeFreedByGC = GCStrategy->canBeFreed(this);
+  if (CanBeFreedByGC)
+    return *CanBeFreedByGC;
+  else
+    // If GC could not figure it out, conservatively answer "yes".
 }
 
 uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
                                                bool &CanBeNull,
                                                bool &CanBeFreed) const {
   assert(getType()->isPointerTy() && "must be pointer");
 
   uint64_t DerefBytes = 0;