LLVM  6.0.0svn
BuiltinGCs.cpp
Go to the documentation of this file.
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 
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  ErlangGC() {
31  InitRoots = false;
32  NeededSafePoints = 1 << GC::PostCall;
33  UsesMetadata = true;
34  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  OcamlGC() {
44  NeededSafePoints = 1 << GC::PostCall;
45  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  ShadowStackGC() {
60  InitRoots = true;
61  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  StatepointGC() {
74  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  InitRoots = false;
78  NeededSafePoints = 0;
79  UsesMetadata = false;
80  CustomRoots = false;
81  }
82 
83  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  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  CoreCLRGC() {
108  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  InitRoots = false;
112  NeededSafePoints = 0;
113  UsesMetadata = false;
114  CustomRoots = false;
115  }
116 
117  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  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");
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.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void linkOcamlGC()
Creates an ocaml-compatible garbage collector.
Definition: BuiltinGCs.cpp:141
void linkErlangGC()
Creates an erlang-compatible garbage collector.
Definition: BuiltinGCs.cpp:140
void linkCoreCLRGC()
FIXME: Collector instances are not useful on their own.
Definition: BuiltinGCs.cpp:144
Class to represent pointers.
Definition: DerivedTypes.h:467
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Instr is the return address of a call.
Definition: GCStrategy.h:70
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:495
void linkShadowStackGC()
Creates a shadow stack garbage collector.
Definition: BuiltinGCs.cpp:142
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
GCStrategy describes a garbage collector algorithm&#39;s code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described.
Definition: GCStrategy.h:80
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
A static registration template.
Definition: Registry.h:115
void linkStatepointExampleGC()
Definition: BuiltinGCs.cpp:143