contrib/llvm/lib/CodeGen/BuiltinGCs.cpp

   1 //===-- BuiltinGCs.cpp - Boilerplate for our built in GC types --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the boilerplate required to define our various built in
  11 // gc lowering strategies.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/CodeGen/GCs.h"
  16 #include "llvm/CodeGen/GCStrategy.h"
  17
  18 using namespace llvm;
  19
  20 namespace {
  21
  22 /// An example GC which attempts to be compatibile with Erlang/OTP garbage
  23 /// collector.
  24 ///
  25 /// The frametable emitter is in ErlangGCPrinter.cpp.
  26 class ErlangGC : public GCStrategy {
  27 public:
  28   ErlangGC() {
  29     InitRoots = false;
  30     NeededSafePoints = 1 << GC::PostCall;
  31     UsesMetadata = true;
  32     CustomRoots = false;
  33   }
  34 };
  35
  36 /// An example GC which attempts to be compatible with Objective Caml 3.10.0
  37 ///
  38 /// The frametable emitter is in OcamlGCPrinter.cpp.
  39 class OcamlGC : public GCStrategy {
  40 public:
  41   OcamlGC() {
  42     NeededSafePoints = 1 << GC::PostCall;
  43     UsesMetadata = true;
  44   }
  45 };
  46
  47 /// A GC strategy for uncooperative targets.  This implements lowering for the
  48 /// llvm.gc* intrinsics for targets that do not natively support them (which
  49 /// includes the C backend). Note that the code generated is not quite as
  50 /// efficient as algorithms which generate stack maps to identify roots.
  51 ///
  52 /// In order to support this particular transformation, all stack roots are
  53 /// coallocated in the stack. This allows a fully target-independent stack map
  54 /// while introducing only minor runtime overhead.
  55 class ShadowStackGC : public GCStrategy {
  56 public:
  57   ShadowStackGC() {
  58     InitRoots = true;
  59     CustomRoots = true;
  60   }
  61 };
  62
  63 /// A GCStrategy which serves as an example for the usage of a statepoint based
  64 /// lowering strategy.  This GCStrategy is intended to suitable as a default
  65 /// implementation usable with any collector which can consume the standard
  66 /// stackmap format generated by statepoints, uses the default addrespace to
  67 /// distinguish between gc managed and non-gc managed pointers, and has
  68 /// reasonable relocation semantics.
  69 class StatepointGC : public GCStrategy {
  70 public:
  71   StatepointGC() {
  72     UseStatepoints = true;
  73     // These options are all gc.root specific, we specify them so that the
  74     // gc.root lowering code doesn't run.
  75     InitRoots = false;
  76     NeededSafePoints = 0;
  77     UsesMetadata = false;
  78     CustomRoots = false;
  79   }
  80   Optional<bool> isGCManagedPointer(const Type *Ty) const override {
  81     // Method is only valid on pointer typed values.
  82     const PointerType *PT = cast<PointerType>(Ty);
  83     // For the sake of this example GC, we arbitrarily pick addrspace(1) as our
  84     // GC managed heap.  We know that a pointer into this heap needs to be
  85     // updated and that no other pointer does.  Note that addrspace(1) is used
  86     // only as an example, it has no special meaning, and is not reserved for
  87     // GC usage.
  88     return (1 == PT->getAddressSpace());
  89   }
  90 };
  91
  92 /// A GCStrategy for the CoreCLR Runtime. The strategy is similar to
  93 /// Statepoint-example GC, but differs from it in certain aspects, such as:
  94 /// 1) Base-pointers need not be explicitly tracked and reported for
  95 ///    interior pointers
  96 /// 2) Uses a different format for encoding stack-maps
  97 /// 3) Location of Safe-point polls: polls are only needed before loop-back
  98 ///    edges and before tail-calls (not needed at function-entry)
  99 ///
 100 /// The above differences in behavior are to be implemented in upcoming
 101 /// checkins.
 102 class CoreCLRGC : public GCStrategy {
 103 public:
 104   CoreCLRGC() {
 105     UseStatepoints = true;
 106     // These options are all gc.root specific, we specify them so that the
 107     // gc.root lowering code doesn't run.
 108     InitRoots = false;
 109     NeededSafePoints = 0;
 110     UsesMetadata = false;
 111     CustomRoots = false;
 112   }
 113   Optional<bool> isGCManagedPointer(const Type *Ty) const override {
 114     // Method is only valid on pointer typed values.
 115     const PointerType *PT = cast<PointerType>(Ty);
 116     // We pick addrspace(1) as our GC managed heap.
 117     return (1 == PT->getAddressSpace());
 118   }
 119 };
 120 }
 121
 122 // Register all the above so that they can be found at runtime.  Note that
 123 // these static initializers are important since the registration list is
 124 // constructed from their storage.
 125 static GCRegistry::Add<ErlangGC> A("erlang",
 126                                    "erlang-compatible garbage collector");
 127 static GCRegistry::Add<OcamlGC> B("ocaml", "ocaml 3.10-compatible GC");
 128 static GCRegistry::Add<ShadowStackGC>
 129     C("shadow-stack", "Very portable GC for uncooperative code generators");
 130 static GCRegistry::Add<StatepointGC> D("statepoint-example",
 131                                        "an example strategy for statepoint");
 132 static GCRegistry::Add<CoreCLRGC> E("coreclr", "CoreCLR-compatible GC");
 133
 134 // Provide hooks to ensure the containing library is fully loaded.
 135 void llvm::linkErlangGC() {}
 136 void llvm::linkOcamlGC() {}
 137 void llvm::linkShadowStackGC() {}
 138 void llvm::linkStatepointExampleGC() {}
 139 void llvm::linkCoreCLRGC() {}