1 //===- BuiltinGCs.cpp - Boilerplate for our built in GC types -------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the boilerplate required to define our various built in
11 // gc lowering strategies.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/CodeGen/BuiltinGCs.h"
16 #include "llvm/CodeGen/GCStrategy.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include "llvm/Support/Casting.h"
24 /// An example GC which attempts to be compatibile with Erlang/OTP garbage
27 /// The frametable emitter is in ErlangGCPrinter.cpp.
28 class ErlangGC : public GCStrategy {
31 NeededSafePoints = true;
36 /// An example GC which attempts to be compatible with Objective Caml 3.10.0
38 /// The frametable emitter is in OcamlGCPrinter.cpp.
39 class OcamlGC : public GCStrategy {
42 NeededSafePoints = true;
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.
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 {
60 /// A GCStrategy which serves as an example for the usage of a statepoint based
61 /// lowering strategy. This GCStrategy is intended to suitable as a default
62 /// implementation usable with any collector which can consume the standard
63 /// stackmap format generated by statepoints, uses the default addrespace to
64 /// distinguish between gc managed and non-gc managed pointers, and has
65 /// reasonable relocation semantics.
66 class StatepointGC : public GCStrategy {
69 UseStatepoints = true;
70 // These options are all gc.root specific, we specify them so that the
71 // gc.root lowering code doesn't run.
72 NeededSafePoints = false;
76 Optional<bool> isGCManagedPointer(const Type *Ty) const override {
77 // Method is only valid on pointer typed values.
78 const PointerType *PT = cast<PointerType>(Ty);
79 // For the sake of this example GC, we arbitrarily pick addrspace(1) as our
80 // GC managed heap. We know that a pointer into this heap needs to be
81 // updated and that no other pointer does. Note that addrspace(1) is used
82 // only as an example, it has no special meaning, and is not reserved for
84 return (1 == PT->getAddressSpace());
88 /// A GCStrategy for the CoreCLR Runtime. The strategy is similar to
89 /// Statepoint-example GC, but differs from it in certain aspects, such as:
90 /// 1) Base-pointers need not be explicitly tracked and reported for
92 /// 2) Uses a different format for encoding stack-maps
93 /// 3) Location of Safe-point polls: polls are only needed before loop-back
94 /// edges and before tail-calls (not needed at function-entry)
96 /// The above differences in behavior are to be implemented in upcoming
98 class CoreCLRGC : public GCStrategy {
101 UseStatepoints = true;
102 // These options are all gc.root specific, we specify them so that the
103 // gc.root lowering code doesn't run.
104 NeededSafePoints = false;
105 UsesMetadata = false;
108 Optional<bool> isGCManagedPointer(const Type *Ty) const override {
109 // Method is only valid on pointer typed values.
110 const PointerType *PT = cast<PointerType>(Ty);
111 // We pick addrspace(1) as our GC managed heap.
112 return (1 == PT->getAddressSpace());
116 } // end anonymous namespace
118 // Register all the above so that they can be found at runtime. Note that
119 // these static initializers are important since the registration list is
120 // constructed from their storage.
121 static GCRegistry::Add<ErlangGC> A("erlang",
122 "erlang-compatible garbage collector");
123 static GCRegistry::Add<OcamlGC> B("ocaml", "ocaml 3.10-compatible GC");
124 static GCRegistry::Add<ShadowStackGC>
125 C("shadow-stack", "Very portable GC for uncooperative code generators");
126 static GCRegistry::Add<StatepointGC> D("statepoint-example",
127 "an example strategy for statepoint");
128 static GCRegistry::Add<CoreCLRGC> E("coreclr", "CoreCLR-compatible GC");
130 // Provide hook to ensure the containing library is fully loaded.
131 void llvm::linkAllBuiltinGCs() {}