Link the default GC strategies everywhere getGCStrategy is used

[znix]

Summary

GC strategies are registed using a system of global constructors: any
object can include a GCRegistry::Add stataic variable to register a
strategy, and that will generate a static constructor which registers
this strategy into a global list.

This allows shared libraries to easily register their own strategies,
but poses a problem related to linking: the default GC strategies
(defined and registered in their own file) must obviously be included in
LLVM binaries.

The previous solution was to define an empty functon in BuiltinGCs.cpp,
and call it from LinkAllCodegenComponents.h - this is the solution used
for many other codegen components. This header is then included into the
llc and lli main source files, ensuring everything gets linked into
those binaries.

This isn't great for GCStrategy, which we'd like [1] to use in other
binaries, notably opt for the RS4GC [2] pass. Instead of doing something
specific to opt (for example, adding a call in LinkAllIR), this patch
links to the registry function from getGCStrategy, in the assumption
that anything that might look up a GC strategy probably also expects
the default strategies to exist.

[1] https://reviews.llvm.org/D140458
[2] RewriteStatepointsForGC

[dantrushin]

Tried your patch together with my old uncommitted change which utilizes GCStrategy in IR Verifier and it works fine now. So LGTM.
Please wait few days for other reviewers to have a chance to comment.

[dantrushin]

OK, go ahead.

[znix]

I don't have commit access, could you please commit it?

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.
       // This is so that globals in the translation units where these functions
       // are defined are forced to be initialized, populating various
       // registries.
       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/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/ADT/Twine.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();
 
+  // We need to link all the builtin GCs when LLVM is used as a static library.
+  // The linker will quite happily remove the static constructors that register
+  // the builtin GCs if we don't use a function from that object. This function
+  // does nothing but we need to make sure it is (or at least could be, even
+  // with all optimisations enabled) called *somewhere*, and this is a good
+  // place to do that: if the GC strategies are being used then this function
+  // obviously can't be removed by the linker, and here it won't affect
+  // performance, since there's about to be a fatal error anyway.
+  llvm::linkAllBuiltinGCs();
+
   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(Twine(error));
   } else
     report_fatal_error(Twine(std::string("unsupported GC: ") + Name.str()));
 }