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