Move ownership of GCStrategy objects to LLVMContext

[reames]

Summary

(I would appreciate a close review on this one. I'm changing ownership in a non-trivial way and am introducing what might be considered a layering violation - IR owrning and returning pointers to a CodeGen class.)

Rather than have the GCStrategy object owned by the GCModuleInfo - which is an immutable analysis pass used mainly by gc.root - have it be owned by the LLVMContext. This simplifies the ownership logic (i.e. can you have two instances of the same strategy at once?), but more importantly, allows us to access the GCStrategy in the middle end optimizer. To this end, I add an accessor through Function which becomes the canonical way to get at a GCStrategy instance.

In the near future, this will allows me to move some of the checks from http://reviews.llvm.org/D6808 into the Verifier itself, and to introduce optimization legality predicates for some of the recent additions to InstCombine. (These will follow as separate changes.)

[artagnon]

A small review, fwiw.

include/llvm/CodeGen/GCMetadata.h

167 ↗

(On Diff #17721)

Why didn't you preserve std::unique_ptr?

170 ↗

(On Diff #17721)

You have a GCStrategyList, GCStrategyMap, and StrategyMap? Makes me wonder what happened to the corresponding StrategyList.

include/llvm/CodeGen/GCStrategy.h

54 ↗

(On Diff #17721)

This is unrelated to the overall change, isn't it? (Just asking)

70 ↗

(On Diff #17721)

So this is the big change. GCModuleInfo benefited from this friendship by being able to instantiate and Name strategies from the GCRegistry. Now, you've removed that code and put it in ContextImpl.

lib/CodeGen/GCMetadata.cpp

80 ↗

(On Diff #17721)

There is no user of this StrategyList. The only iterator I can see is in getGCStrategy(), and that uses GCStrategyList. What is this for?

lib/IR/LLVMContextImpl.cpp

16 ↗

(On Diff #17721)

Some final comments:
If I understand correctly, your patch helps us verify and optimize the code generated by gc plugins, hence making their lives easier.

[reames]

include/llvm/CodeGen/GCMetadata.h

167 ↗

(On Diff #17721)

The GCStrategy is no longer owned by the GCModuleInfo.

170 ↗

(On Diff #17721)

Sorry, what? I don't understand your comment.

include/llvm/CodeGen/GCStrategy.h

54 ↗

(On Diff #17721)

Not really. I'm removing headers which were only required by the deleted code and adding back a header which was an indirect dependency.

lib/CodeGen/GCMetadata.cpp

80 ↗

(On Diff #17721)

Again, what? There is no GCStrategyList member variable.

lib/IR/LLVMContextImpl.cpp

16 ↗

(On Diff #17721)

I'd frame this differently: "it helps us verify and optimize code compiled for targets with a garbage collector". But the difference is minor.

[sanjoy]

Some minor nits inline. I think the ownership change is okay, but I'm not confident enough in that judgement to LGTM it.

lib/IR/Function.cpp

393 ↗

(On Diff #17721)

LLVM style says LLVMContextImpl *pImpl and const char *Name.

393 ↗

(On Diff #17721)

Why not just getContext().pImpl?

lib/IR/LLVMContextImpl.cpp

177 ↗

(On Diff #17721)

ProgrammersManual.rst says "`StringRef` is small and pervasive enough in LLVM that it should always be passed by value."

188 ↗

(On Diff #17721)

Not part of the review, but is this complexity (the StringMap) actually needed? I'd think the usual case has just one GC strategy.

[artagnon]

lib/CodeGen/GCMetadata.cpp

80 ↗

(On Diff #17721)

I've probably been staring at this for too long, but StrategyList doesn't really seem to be looked up or iterated over anywhere. Can you show me a counterexample? Dump from a git-grep:

artagnon|gc-relocate>:~/src/llvm$ g g StrategyList
include/llvm/CodeGen/GCMetadata.h=43=namespace llvm {
include/llvm/CodeGen/GCMetadata.h:171:    list_type StrategyList;
include/llvm/CodeGen/GCMetadata.h:207:    iterator begin() const { return StrategyList.begin(); }
include/llvm/CodeGen/GCMetadata.h:208:    iterator end()   const { return StrategyList.end();   }
lib/CodeGen/GCMetadata.cpp=64=GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M,
lib/CodeGen/GCMetadata.cpp:76:      StrategyList.push_back(std::move(S));
lib/CodeGen/GCMetadata.cpp:77:      return StrategyList.back().get();
lib/CodeGen/GCMetadata.cpp=100=void GCModuleInfo::clear() {
lib/CodeGen/GCMetadata.cpp:104:  StrategyList.clear();

[artagnon]

lib/CodeGen/GCMetadata.cpp

80 ↗

(On Diff #17721)

Uh, never mind. GCModuleInfo::iterator is used in LowerIntrinsics::doInitialization() and AsmPrinter::doFinalization().

Sorry about that.

*goes to get more coffee*

[reames]

Address Sanjoy's style comments and add some header includes to fix a build issue on TOT.

ping - specifically regards to the ownership, everything else has been reviewed

[reames]

ping

This is blocking work I'd like to get in before we cut 3.6. The only
part left to review is having someone look over the ownership changes
for GCStrategy and make sure I haven't missed something. The code has
already been reviewed, just not by someone who felt comfortable with the
ownership changes.

If I haven't received a response on the ownership changes by tomorrow,
I'm going to go ahead and submit. I know this is not generally accepted
practice, but given the code has been reviewed, if not with the emphasis
I'd prefer, and that the change itself is fairly simple, I'm going to
submit unless someone objects.

Philip

[nicholas]

Philip Reames wrote:

Hi chandlerc, nicholas, sanjoy,

(I would appreciate a close review on this one. I'm changing ownership in a non-trivial way and am introducing what might be considered a layering violation - IR owrning and returning pointers to a CodeGen class.)

Sorry but that's a non-starter right there. We can't have IR depending
on Codegen (unless you want to make Codegen not depend on IR).

We can cheat a little; we could move GCStrategy.h into the IR and
forward-declare MachineFunction and pass it by pointer to
findCustomSafePoints.

Should there be a split, GCStrategy (IR) and MachineGCStrategy? There
isn't enough IR-side user of the new API for me to judge how to deal
with it, even D6808 pretty much just uses isGCManagedPointer.

+ for (GCRegistry::iterator I = GCRegistry::begin(),
+ E = GCRegistry::end(); I != E; ++I) {

Range-based for loop?

Rather than have the GCStrategy object owned by the GCModuleInfo - which is an immutable analysis pass used mainly by gc.root - have it be owned by the LLVMContext. This simplifies the ownership logic (i.e. can you have two instances of the same strategy at once?), but more importantly, allows us to access the GCStrategy in the middle end optimizer. To this end, I add an accessor through Function which becomes the canonical way to get at a GCStrategy instance.

In the near future, this will allows me to move some of the checks from http://reviews.llvm.org/D6808 into the Verifier itself, and to introduce optimization legality predicates for some of the recent additions to InstCombine. (These will follow as separate changes.)

http://reviews.llvm.org/D6811

Files:

include/llvm/CodeGen/GCMetadata.h
include/llvm/CodeGen/GCStrategy.h
include/llvm/IR/Function.h
lib/CodeGen/GCMetadata.cpp
lib/IR/Function.cpp
lib/IR/LLVMContextImpl.cpp
lib/IR/LLVMContextImpl.h

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

[reames]

Updates based on Chandlers comments. GCStrategy is completely moved into IR. I haven't gone through and fixed all the comments yet, but will do so once this lands.

Note that this is dependent on http://reviews.llvm.org/D7004 and that supporting refactoring (splitting GCStrategy.cpp into two files) already landing.

I would also like to get rid of the performCustomLowering mechanism, but that should not block this and will require a bit more thought.

[chandlerc]

Ok, I think this is looking pretty good in general.

I have one major question left. Does this need to be baked into the IR / context? My *impression* is that the goal here is really just to cache the formation of the GCStrategy object which happens by parsing an attribute. Do I understand this correctly?

If so, have you looked at possibly making this a function analysis that has a cache of these which it populates exactly the same way you populate the context? That should still allow you to use essentially the same lookup path here.

The reason I suggest this approach is that it helps simplify the core IR a bit by letting the IR just deal in an opaque attribute and relying on an analysis to reason about it. I think the code would be almost identical to what you have here just shuffled around a bit. I'd be happy with that either as the first version or with that happening as the immediate follow-up refactoring after this patch.

Also a few trivial comments inline.

include/llvm/CodeGen/GCMetadata.h

46 ↗

(On Diff #18263)

Stale forward declaration.

157–160 ↗

(On Diff #18263)

I would nuke the typedef (or at least fix its name) at this point.

Also, "no longer" doesn't really make sense in a comment where there is no visible history.

lib/IR/LLVMContextImpl.cpp

183–184 ↗

(On Diff #18263)

Range based loop?

[chandlerc]

So, I don't know the GC code at all and am assuming that GCStrategy.{h,cpp} are just moves of existing code. But provided that there is nothing interesting about the GC side of this and my understanding of the move is correct, this change looks good with the comments on the changed (not moved) code addressed. Two more minor ones below.

lib/CodeGen/GCMetadata.cpp

74–75 ↗

(On Diff #18263)

Use report_fatal_error here.

lib/IR/Function.cpp

392–393 ↗

(On Diff #18263)

This variable doesn't seem to be adding much...

llvm/trunk/include/llvm/CodeGen/GCMetadata.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_GCMETADATA_H
 #define LLVM_CODEGEN_GCMETADATA_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/Pass.h"
 #include <memory>
 
 namespace llvm {
   class AsmPrinter;
-  class GCStrategy;
   class Constant;
   class MCSymbol;
 
-  namespace GC {
-    /// PointKind - The type of a collector-safe point.
-    ///
-    enum PointKind {
-      Loop,    ///< Instr is a loop (backwards branch).
-      Return,  ///< Instr is a return instruction.
-      PreCall, ///< Instr is a call instruction.
-      PostCall ///< Instr is the return address of a call.
-    };
-  }
-
   /// GCPoint - Metadata for a collector-safe point in machine code.
   ///
   struct GCPoint {
     GC::PointKind Kind; ///< The kind of the safe point.
     MCSymbol *Label;    ///< A label.
     DebugLoc Loc;
 
     GCPoint(GC::PointKind K, MCSymbol *L, DebugLoc DL)
public:
     live_iterator live_end  (const iterator &p) { return roots_end();   }
     size_t live_size(const iterator &p) const { return roots_size(); }
   };
 
   /// An analysis pass which caches information about the entire Module.
   /// Records both the function level information used by GCRoots and a
   /// cache of the 'active' gc strategy objects for the current Module.
   class GCModuleInfo : public ImmutablePass {
-    typedef StringMap<GCStrategy*> strategy_map_type;
-    typedef std::vector<std::unique_ptr<GCStrategy>> list_type;
-
-    strategy_map_type StrategyMap;
-    list_type StrategyList;
-
-    GCStrategy *getOrCreateStrategy(const Module *M, const std::string &Name);
-
+    /// A list of GCStrategies which are active in this Module.  These are
+    /// not owning pointers.
+    std::vector<GCStrategy*> StrategyList;
   public:
     /// List of per function info objects.  In theory, Each of these
     /// may be associated with a different GC.
     typedef std::vector<std::unique_ptr<GCFunctionInfo>> FuncInfoVec;
 
     FuncInfoVec::iterator funcinfo_begin() { return Functions.begin(); }
     FuncInfoVec::iterator funcinfo_end()   { return Functions.end();   }
     
 
   private:
     /// Owning list of all GCFunctionInfos associated with this Module
     FuncInfoVec Functions;
 
     /// Non-owning map to bypass linear search when finding the GCFunctionInfo
     /// associated with a particular Function.
     typedef DenseMap<const Function*,GCFunctionInfo*> finfo_map_type;
     finfo_map_type FInfoMap;
   public:
 
-    typedef list_type::const_iterator iterator;
+    typedef std::vector<GCStrategy*>::const_iterator iterator;
 
     static char ID;
 
     GCModuleInfo();
 
     /// clear - Resets the pass. Any pass, which uses GCModuleInfo, should
     /// call it in doFinalization().
     ///

llvm/trunk/include/llvm/CodeGen/GCMetadataPrinter.h

 // because these subclasses are logically plugins for the AsmWriter.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_GCMETADATAPRINTER_H
 #define LLVM_CODEGEN_GCMETADATAPRINTER_H
 
 #include "llvm/CodeGen/GCMetadata.h"
-#include "llvm/CodeGen/GCStrategy.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/Support/Registry.h"
 
 namespace llvm {
 
   class GCMetadataPrinter;
 
   /// GCMetadataPrinterRegistry - The GC assembly printer registry uses all the
   /// defaults from Registry.

llvm/trunk/include/llvm/CodeGen/GCStrategy.h

-//===-- llvm/CodeGen/GCStrategy.h - Garbage collection ----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// GCStrategy coordinates code generation algorithms and implements some itself
-// in order to generate code compatible with a target code generator as
-// specified in a function's 'gc' attribute. Algorithms are enabled by setting
-// flags in a subclass's constructor, and some virtual methods can be
-// overridden.
-//
-// GCStrategy is relevant for implementations using either gc.root or
-// gc.statepoint based lowering strategies, but is currently focused mostly on
-// options for gc.root.  This will change over time.
-// 
-// When requested by a subclass of GCStrategy, the gc.root implementation will
-// populate GCModuleInfo and GCFunctionInfo with that about each Function in
-// the Module that opts in to garbage collection.  Specifically:
-// 
-// - Safe points
-//   Garbage collection is generally only possible at certain points in code.
-//   GCStrategy can request that the collector insert such points:
-//
-//     - At and after any call to a subroutine
-//     - Before returning from the current function
-//     - Before backwards branches (loops)
-// 
-// - Roots
-//   When a reference to a GC-allocated object exists on the stack, it must be
-//   stored in an alloca registered with llvm.gcoot.
-//
-// This information can used to emit the metadata tables which are required by
-// the target garbage collector runtime.
-//
-// When used with gc.statepoint, information about safepoint and roots can be
-// found in the binary StackMap section after code generation.  Safepoint
-// placement is currently the responsibility of the frontend, though late
-// insertion support is planned.  gc.statepoint does not currently support
-// custom stack map formats; such can be generated by parsing the standard
-// stack map section if desired.
-// 
-// The read and write barrier support can be used with either implementation.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CODEGEN_GCSTRATEGY_H
-#define LLVM_CODEGEN_GCSTRATEGY_H
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/CodeGen/GCMetadata.h"
-#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/Support/Registry.h"
-#include <string>
-
-namespace llvm {
-  /// GCStrategy describes a garbage collector algorithm's code generation
-  /// requirements, and provides overridable hooks for those needs which cannot
-  /// be abstractly described.  GCStrategy objects currently must be looked up
-  /// through the GCModuleInfo analysis pass.  They are owned by the analysis
-  /// pass and recreated every time that pass is invalidated.
-  class GCStrategy {
-  private:
-    std::string Name;
-    friend class GCModuleInfo;
-    
-  protected:
-    bool UseStatepoints;       /// Uses gc.statepoints as opposed to gc.roots,
-                               /// if set, none of the other options can be
-                               /// anything but their default values.
-
-    unsigned NeededSafePoints; ///< Bitmask of required safe points.
-    bool CustomReadBarriers;   ///< Default is to insert loads.
-    bool CustomWriteBarriers;  ///< Default is to insert stores.
-    bool CustomRoots;          ///< Default is to pass through to backend.
-    bool InitRoots;            ///< If set, roots are nulled during lowering.
-    bool UsesMetadata;         ///< If set, backend must emit metadata tables.
-    
-  public:
-    GCStrategy();
-    virtual ~GCStrategy() {}
-    
-    /// Return the name of the GC strategy.  This is the value of the collector
-    /// name string specified on functions which use this strategy.
-    const std::string &getName() const { return Name; }
-
-    /// By default, write barriers are replaced with simple store
-    /// instructions. If true, then performCustomLowering must instead lower
-    /// them. 
-    bool customWriteBarrier() const { return CustomWriteBarriers; }
-    
-    /// By default, read barriers are replaced with simple load
-    /// instructions. If true, then performCustomLowering must instead lower
-    /// them. 
-    bool customReadBarrier() const { return CustomReadBarriers; }
-
-    /// Returns true if this strategy is expecting the use of gc.statepoints,
-    /// and false otherwise.
-    bool useStatepoints() const { return UseStatepoints; }
-
-    /** @name Statepoint Specific Properties */
-    ///@{
-
-    /// If the value 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 'None' (i.e. an
-    /// empty optional indicating it can't reliably distinguish.   
-    virtual Optional<bool> isGCManagedPointer(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 of any kind are required. By default, none are
-    /// recorded. 
-    bool needsSafePoints() const {
-      return NeededSafePoints != 0;
-    }
-    
-    /// True if the given kind of safe point is required. By default, none are
-    /// recorded. 
-    bool needsSafePoint(GC::PointKind Kind) const {
-      return (NeededSafePoints & 1 << Kind) != 0;
-    }
-        
-    /// By default, roots are left for the code generator so it can generate a
-    /// stack map. If true, then performCustomLowering must delete them.
-    bool customRoots() const { return CustomRoots; }
-
-    /// If set, gcroot intrinsics should initialize their allocas to null
-    /// before the first use. This is necessary for most GCs and is enabled by
-    /// default. 
-    bool initializeRoots() const { return InitRoots; }
-    
-    /// If set, appropriate metadata tables must be emitted by the back-end
-    /// (assembler, JIT, or otherwise). For statepoint, this method is
-    /// currently unsupported.  The stackmap information can be found in the
-    /// StackMap section as described in the documentation.
-    bool usesMetadata() const { return UsesMetadata; }
-
-    ///@}
-    
-    /// initializeCustomLowering/performCustomLowering - If any of the actions
-    /// are set to custom, performCustomLowering must be overriden to transform
-    /// the corresponding actions to LLVM IR. initializeCustomLowering is
-    /// optional to override. These are the only GCStrategy methods through
-    /// which the LLVM IR can be modified.  These methods apply mostly to
-    /// gc.root based implementations, but can be overriden to provide custom
-    /// barrier lowerings with gc.statepoint as well.
-    ///@{
-    virtual bool initializeCustomLowering(Module &F) {
-      // No changes made
-      return false;
-    }
-    virtual bool performCustomLowering(Function &F) {
-      llvm_unreachable("GCStrategy subclass specified a configuration which"
-                       "requires a custom lowering without providing one");
-    }
-  };
-
-  /// Subclasses of GCStrategy are made available for use during compilation by
-  /// adding them to the global GCRegistry.  This can done either within the
-  /// LLVM source tree or via a loadable plugin.  An example registeration
-  /// would be:
-  /// static GCRegistry::Add<CustomGC> X("custom-name",
-  ///        "my custom supper fancy gc strategy");
-  /// 
-  /// Note that to use a custom GCMetadataPrinter w/gc.roots, you must also
-  /// register your GCMetadataPrinter subclass with the
-  /// GCMetadataPrinterRegistery as well. 
-  typedef Registry<GCStrategy> GCRegistry;
-}
-
-#endif

llvm/trunk/include/llvm/IR/Function.h

 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 class FunctionType;
+class GCStrategy;  
 class LLVMContext;
 
 // Traits for intrusive list of basic blocks...
 template<> struct ilist_traits<BasicBlock>
   : public SymbolTableListTraits<BasicBlock, Function> {
 
   // createSentinel is used to get hold of the node that marks the end of the
   // list... (same trick used here as in ilist_traits<Instruction>)
public:
 
   /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
   ///                             to use during code generation.
   bool hasGC() const;
   const char *getGC() const;
   void setGC(const char *Str);
   void clearGC();
 
+  /// Returns the GCStrategy associated with the specified garbage collector
+  /// algorithm or nullptr if one is not set.
+  GCStrategy *getGCStrategy() const;
+
   /// @brief adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind attr);
 
   /// @brief adds the attributes to the list of attributes.
   void addAttributes(unsigned i, AttributeSet attrs);
 
   /// @brief removes the attributes from the list of attributes.
   void removeAttributes(unsigned i, AttributeSet attr);

llvm/trunk/include/llvm/IR/GCStrategy.h

+//===-- llvm/IR/GCStrategy.h - Garbage collection ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// GCStrategy coordinates code generation algorithms and implements some itself
+// in order to generate code compatible with a target code generator as
+// specified in a function's 'gc' attribute. Algorithms are enabled by setting
+// flags in a subclass's constructor, and some virtual methods can be
+// overridden.
+//
+// GCStrategy is relevant for implementations using either gc.root or
+// gc.statepoint based lowering strategies, but is currently focused mostly on
+// options for gc.root.  This will change over time.
+// 
+// When requested by a subclass of GCStrategy, the gc.root implementation will
+// populate GCModuleInfo and GCFunctionInfo with that about each Function in
+// the Module that opts in to garbage collection.  Specifically:
+// 
+// - Safe points
+//   Garbage collection is generally only possible at certain points in code.
+//   GCStrategy can request that the collector insert such points:
+//
+//     - At and after any call to a subroutine
+//     - Before returning from the current function
+//     - Before backwards branches (loops)
+// 
+// - Roots
+//   When a reference to a GC-allocated object exists on the stack, it must be
+//   stored in an alloca registered with llvm.gcoot.
+//
+// This information can used to emit the metadata tables which are required by
+// the target garbage collector runtime.
+//
+// When used with gc.statepoint, information about safepoint and roots can be
+// found in the binary StackMap section after code generation.  Safepoint
+// placement is currently the responsibility of the frontend, though late
+// insertion support is planned.  gc.statepoint does not currently support
+// custom stack map formats; such can be generated by parsing the standard
+// stack map section if desired.
+// 
+// The read and write barrier support can be used with either implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_GCSTRATEGY_H
+#define LLVM_IR_GCSTRATEGY_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/IR/Value.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Registry.h"
+#include <string>
+
+namespace llvm {
+  namespace GC {
+    /// PointKind - The type of a collector-safe point.
+    ///
+    enum PointKind {
+      Loop,    ///< Instr is a loop (backwards branch).
+      Return,  ///< Instr is a return instruction.
+      PreCall, ///< Instr is a call instruction.
+      PostCall ///< Instr is the return address of a call.
+    };
+  }
+
+  
+  /// 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:
+    std::string Name;
+    friend class LLVMContextImpl;
+    
+  protected:
+    bool UseStatepoints;       /// Uses gc.statepoints as opposed to gc.roots,
+                               /// if set, none of the other options can be
+                               /// anything but their default values.
+
+    unsigned NeededSafePoints; ///< Bitmask of required safe points.
+    bool CustomReadBarriers;   ///< Default is to insert loads.
+    bool CustomWriteBarriers;  ///< Default is to insert stores.
+    bool CustomRoots;          ///< Default is to pass through to backend.
+    bool InitRoots;            ///< If set, roots are nulled during lowering.
+    bool UsesMetadata;         ///< If set, backend must emit metadata tables.
+    
+  public:
+    GCStrategy();
+    virtual ~GCStrategy() {}
+    
+    /// Return the name of the GC strategy.  This is the value of the collector
+    /// name string specified on functions which use this strategy.
+    const std::string &getName() const { return Name; }
+
+    /// By default, write barriers are replaced with simple store
+    /// instructions. If true, then performCustomLowering must instead lower
+    /// them. 
+    bool customWriteBarrier() const { return CustomWriteBarriers; }
+    
+    /// By default, read barriers are replaced with simple load
+    /// instructions. If true, then performCustomLowering must instead lower
+    /// them. 
+    bool customReadBarrier() const { return CustomReadBarriers; }
+
+    /// Returns true if this strategy is expecting the use of gc.statepoints,
+    /// and false otherwise.
+    bool useStatepoints() const { return UseStatepoints; }
+
+    /** @name Statepoint Specific Properties */
+    ///@{
+
+    /// If the value 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 'None' (i.e. an
+    /// empty optional indicating it can't reliably distinguish.   
+    virtual Optional<bool> isGCManagedPointer(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 of any kind are required. By default, none are
+    /// recorded. 
+    bool needsSafePoints() const {
+      return NeededSafePoints != 0;
+    }
+    
+    /// True if the given kind of safe point is required. By default, none are
+    /// recorded. 
+    bool needsSafePoint(GC::PointKind Kind) const {
+      return (NeededSafePoints & 1 << Kind) != 0;
+    }
+        
+    /// By default, roots are left for the code generator so it can generate a
+    /// stack map. If true, then performCustomLowering must delete them.
+    bool customRoots() const { return CustomRoots; }
+
+    /// If set, gcroot intrinsics should initialize their allocas to null
+    /// before the first use. This is necessary for most GCs and is enabled by
+    /// default. 
+    bool initializeRoots() const { return InitRoots; }
+    
+    /// If set, appropriate metadata tables must be emitted by the back-end
+    /// (assembler, JIT, or otherwise). For statepoint, this method is
+    /// currently unsupported.  The stackmap information can be found in the
+    /// StackMap section as described in the documentation.
+    bool usesMetadata() const { return UsesMetadata; }
+
+    ///@}
+    
+    /// initializeCustomLowering/performCustomLowering - If any of the actions
+    /// are set to custom, performCustomLowering must be overriden to transform
+    /// the corresponding actions to LLVM IR. initializeCustomLowering is
+    /// optional to override. These are the only GCStrategy methods through
+    /// which the LLVM IR can be modified.  These methods apply mostly to
+    /// gc.root based implementations, but can be overriden to provide custom
+    /// barrier lowerings with gc.statepoint as well.
+    ///@{
+    virtual bool initializeCustomLowering(Module &F) {
+      // No changes made
+      return false;
+    }
+    virtual bool performCustomLowering(Function &F) {
+      llvm_unreachable("GCStrategy subclass specified a configuration which"
+                       "requires a custom lowering without providing one");
+    }
+  };
+
+  /// Subclasses of GCStrategy are made available for use during compilation by
+  /// adding them to the global GCRegistry.  This can done either within the
+  /// LLVM source tree or via a loadable plugin.  An example registeration
+  /// would be:
+  /// static GCRegistry::Add<CustomGC> X("custom-name",
+  ///        "my custom supper fancy gc strategy");
+  /// 
+  /// Note that to use a custom GCMetadataPrinter w/gc.roots, you must also
+  /// register your GCMetadataPrinter subclass with the
+  /// GCMetadataPrinterRegistery as well. 
+  typedef Registry<GCStrategy> GCRegistry;
+}
+
+#endif

llvm/trunk/include/llvm/Support/Registry.h

public:
       iterator &operator++() { Cur = Cur->Next; return *this; }
       const entry &operator*() const { return Cur->Val; }
       const entry *operator->() const { return &Cur->Val; }
     };
 
     static iterator begin() { return iterator(Head); }
     static iterator end()   { return iterator(nullptr); }
 
+    static iterator_range<iterator> entries() {
+      return iterator_range<iterator>(begin(), end());
+    }
+
 
     /// Abstract base class for registry listeners, which are informed when new
     /// entries are added to the registry. Simply subclass and instantiate:
     ///
     /// \code
     ///   class CollectorPrinter : public Registry<Collector>::listener {
     ///   protected:
     ///     void registered(const Registry<Collector>::entry &e) {

llvm/trunk/lib/CodeGen/CMakeLists.txt

add_llvm_library(LLVMCodeGen
   ErlangGC.cpp
   ExecutionDepsFix.cpp
   ExpandISelPseudos.cpp
   ExpandPostRAPseudos.cpp
   ForwardControlFlowIntegrity.cpp
   GCMetadata.cpp
   GCMetadataPrinter.cpp
   GCRootLowering.cpp
-  GCStrategy.cpp
   GlobalMerge.cpp
   IfConversion.cpp
   InlineSpiller.cpp
   InterferenceCache.cpp
   IntrinsicLowering.cpp
   JumpInstrTables.cpp
   LLVMTargetMachine.cpp
   LatencyPriorityQueue.cpp

llvm/trunk/lib/CodeGen/ErlangGC.cpp

 // This file implements the Erlang/OTP runtime-compatible garbage collector
 // (e.g. defines safe points, root initialization etc.)
 //
 // The frametable emitter is in ErlangGCPrinter.cpp.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GCs.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 
 using namespace llvm;
 

llvm/trunk/lib/CodeGen/GCMetadata.cpp

 //===-- GCMetadata.cpp - Garbage collector metadata -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the GCFunctionInfo class and GCModuleInfo pass.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GCMetadata.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 namespace {

 
 char GCModuleInfo::ID = 0;
 
 GCModuleInfo::GCModuleInfo()
     : ImmutablePass(ID) {
   initializeGCModuleInfoPass(*PassRegistry::getPassRegistry());
 }
 
-GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M,
-                                              const std::string &Name) {
-  strategy_map_type::iterator NMI = StrategyMap.find(Name);
-  if (NMI != StrategyMap.end())
-    return NMI->getValue();
-  
-  for (GCRegistry::iterator I = GCRegistry::begin(),
-                            E = GCRegistry::end(); I != E; ++I) {
-    if (Name == I->getName()) {
-      std::unique_ptr<GCStrategy> S = I->instantiate();
-      S->Name = Name;
-      StrategyMap[Name] = S.get();
-      StrategyList.push_back(std::move(S));
-      return StrategyList.back().get();
-    }
-  }
- 
-  dbgs() << "unsupported GC: " << Name << "\n";
-  llvm_unreachable(nullptr);
-}
-
 GCFunctionInfo &GCModuleInfo::getFunctionInfo(const Function &F) {
   assert(!F.isDeclaration() && "Can only get GCFunctionInfo for a definition!");
   assert(F.hasGC());
   
   finfo_map_type::iterator I = FInfoMap.find(&F);
   if (I != FInfoMap.end())
     return *I->second;
   
-  GCStrategy *S = getOrCreateStrategy(F.getParent(), F.getGC());
+  GCStrategy *S = F.getGCStrategy();
+  if (!S) {
+    std::string error = std::string("unsupported GC: ") + F.getGC();
+    report_fatal_error(error);
+  }
+  // Save the fact this strategy is associated with this module.  Note that
+  // these are non-owning references, the GCStrategy remains owned by the
+  // Context. 
+  StrategyList.push_back(S);
   Functions.push_back(make_unique<GCFunctionInfo>(F, *S));
   GCFunctionInfo *GFI = Functions.back().get();
   FInfoMap[&F] = GFI;
   return *GFI;
 }
 
 void GCModuleInfo::clear() {
   Functions.clear();
   FInfoMap.clear();
-  StrategyMap.clear();
   StrategyList.clear();
 }
 
 // -----------------------------------------------------------------------------
 
 char Printer::ID = 0;
 
 FunctionPass *llvm::createGCInfoPrinter(raw_ostream &OS) {

llvm/trunk/lib/CodeGen/GCRootLowering.cpp

 //===-- GCRootLowering.cpp - Garbage collection infrastructure ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the lowering for the gc.root mechanism.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/GCStrategy.h"
+#include "llvm/CodeGen/GCMetadata.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"

llvm/trunk/lib/CodeGen/GCStrategy.cpp

-//===-- GCStrategy.cpp - Garbage Collector Description --------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the policy object GCStrategy which describes the
-// behavior of a given garbage collector.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/CodeGen/GCStrategy.h"
-
-using namespace llvm;
-
-GCStrategy::GCStrategy()
-    : UseStatepoints(false), NeededSafePoints(0), CustomReadBarriers(false),
-      CustomWriteBarriers(false), CustomRoots(false),
-      InitRoots(true), UsesMetadata(false) {}

llvm/trunk/lib/CodeGen/OcamlGC.cpp

 // This file implements lowering for the llvm.gc* intrinsics compatible with
 // Objective Caml 3.10.0, which uses a liveness-accurate static stack map.
 //
 // The frametable emitter is in OcamlGCPrinter.cpp.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GCs.h"
-#include "llvm/CodeGen/GCStrategy.h"
+#include "llvm/IR/GCStrategy.h"
 
 using namespace llvm;
 
 namespace {
   class OcamlGC : public GCStrategy {
   public:
     OcamlGC();
   };

llvm/trunk/lib/CodeGen/Passes.cpp

 //===-- Passes.cpp - Target independent code generation passes ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines interfaces to access the target independent code
 // generation passes provided by the LLVM backend.
 //
 //===---------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/Analysis/Passes.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/FastISel.h"
 #include "llvm/CodeGen/FunctionLoweringInfo.h"
 #include "llvm/CodeGen/GCMetadata.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Statepoint.h"

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/FastISel.h"
 #include "llvm/CodeGen/FunctionLoweringInfo.h"
 #include "llvm/CodeGen/GCMetadata.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
 #include "llvm/CodeGen/SchedulerRegistry.h"
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/Compiler.h"

llvm/trunk/lib/CodeGen/SelectionDAG/StatepointLowering.cpp

 // statepoint sequence in SelectionDAG IR.
 //
 //===----------------------------------------------------------------------===//
 
 #include "StatepointLowering.h"
 #include "SelectionDAGBuilder.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/CodeGen/GCMetadata.h"
 #include "llvm/CodeGen/FunctionLoweringInfo.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/IR/CallingConv.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Statepoint.h"
 #include "llvm/Target/TargetLowering.h"
 #include <algorithm>
 using namespace llvm;
 

llvm/trunk/lib/CodeGen/ShadowStackGC.cpp

 // In order to support this particular transformation, all stack roots are
 // coallocated in the stack. This allows a fully target-independent stack map
 // while introducing only minor runtime overhead.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GCs.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/IR/CallSite.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "shadowstackgc"
 

llvm/trunk/lib/CodeGen/StatepointExampleGC.cpp

 // of a statepoint based lowering strategy.  This GCStrategy is intended to
 // suitable as a default 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.  
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/GCStrategy.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Value.h"
 
 using namespace llvm;
 
 namespace {
 class StatepointGC : public GCStrategy {
 public:

llvm/trunk/lib/IR/CMakeLists.txt

add_llvm_library(LLVMCore
   DataLayout.cpp
   DebugInfo.cpp
   DebugLoc.cpp
   DiagnosticInfo.cpp
   DiagnosticPrinter.cpp
   Dominators.cpp
   Function.cpp
   GCOV.cpp
+  GCStrategy.cpp
   GVMaterializer.cpp
   Globals.cpp
   IRBuilder.cpp
   IRPrintingPasses.cpp
   InlineAsm.cpp
   Instruction.cpp
   Instructions.cpp
   IntrinsicInst.cpp

llvm/trunk/lib/IR/Function.cpp

if (GCNames->empty()) {
       if (GCNamePool->empty()) {
         delete GCNamePool;
         GCNamePool = nullptr;
       }
     }
   }
 }
 
+GCStrategy *Function::getGCStrategy() const {
+  // Lookup the GCStrategy (which is owned by the Context), given the name of
+  // the GC in question.
+  return getContext().pImpl->getGCStrategy(getGC());
+}
+
 /// copyAttributesFrom - copy all additional attributes (those not needed to
 /// create a Function) from the Function Src to this one.
 void Function::copyAttributesFrom(const GlobalValue *Src) {
   assert(isa<Function>(Src) && "Expected a Function!");
   GlobalObject::copyAttributesFrom(Src);
   const Function *SrcF = cast<Function>(Src);
   setCallingConv(SrcF->getCallingConv());
   setAttributes(SrcF->getAttributes());

llvm/trunk/lib/IR/GCStrategy.cpp

+//===-- GCStrategy.cpp - Garbage Collector Description --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the policy object GCStrategy which describes the
+// behavior of a given garbage collector.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/GCStrategy.h"
+
+using namespace llvm;
+
+GCStrategy::GCStrategy()
+    : UseStatepoints(false), NeededSafePoints(0), CustomReadBarriers(false),
+      CustomWriteBarriers(false), CustomRoots(false),
+      InitRoots(true), UsesMetadata(false) {}

llvm/trunk/lib/IR/LLVMContextImpl.h

 
 namespace llvm {
 
 class ConstantInt;
 class ConstantFP;
 class DiagnosticInfoOptimizationRemark;
 class DiagnosticInfoOptimizationRemarkMissed;
 class DiagnosticInfoOptimizationRemarkAnalysis;
+class GCStrategy;
 class LLVMContext;
 class Type;
 class Value;
 
 struct DenseMapAPIntKeyInfo {
   static inline APInt getEmptyKey() {
     APInt V(nullptr, 0);
     V.VAL = 0;
public:
   /// \brief Mapping from a function to its prologue data, which is stored as
   /// the operand of an unparented ReturnInst so that the prologue data has a
   /// Use.
   typedef DenseMap<const Function *, ReturnInst *> PrologueDataMapTy;
   PrologueDataMapTy PrologueDataMap;
 
   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
-  
+  /// An owning list of all GCStrategies which have been created
+  SmallVector<std::unique_ptr<GCStrategy>, 1> GCStrategyList;
+  /// A helper map to speedup lookups into the above list
+  StringMap<GCStrategy*> GCStrategyMap;
+
+  /// Lookup the GCStrategy object associated with the given gc name.  If one
+  /// can't be found, returns nullptr.  The lifetime of the returned objects
+  /// is dictated by the lifetime of the associated context.  No caller should
+  /// attempt to delete the returned objects.
+  GCStrategy *getGCStrategy(const StringRef Name);
+  
   LLVMContextImpl(LLVMContext &C);
   ~LLVMContextImpl();
 };
 
 }
 
 #endif

llvm/trunk/lib/IR/LLVMContextImpl.cpp

 //  This file implements the opaque LLVMContextImpl.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/Module.h"
 #include <algorithm>
 using namespace llvm;
 
 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
   : TheTrueVal(nullptr), TheFalseVal(nullptr),
     VoidTy(C, Type::VoidTyID),
     LabelTy(C, Type::LabelTyID),

 
 void ExtractValueConstantExpr::anchor() { }
 
 void InsertValueConstantExpr::anchor() { }
 
 void GetElementPtrConstantExpr::anchor() { }
 
 void CompareConstantExpr::anchor() { }
+
+GCStrategy *LLVMContextImpl::getGCStrategy(const StringRef Name) {
+  // TODO: Arguably, just doing a linear search would be faster for small N
+  auto NMI = GCStrategyMap.find(Name);
+  if (NMI != GCStrategyMap.end())
+    return NMI->getValue();
+  
+  for (auto& Entry : GCRegistry::entries()) {
+    if (Name == Entry.getName()) {
+      std::unique_ptr<GCStrategy> S = Entry.instantiate();
+      S->Name = Name;
+      GCStrategyMap[Name] = S.get();
+      GCStrategyList.push_back(std::move(S));
+      return GCStrategyList.back().get();
+    }
+  }
+
+  // No GCStrategy found for that name, error reporting is the job of our
+  // callers. 
+  return nullptr;
+}
+
+