LCOV - code coverage report
Current view: top level - lib/CodeGen - BuiltinGCs.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 34 44 77.3 %
Date: 2017-09-14 15:23:50 Functions: 7 19 36.8 %
Legend: Lines: hit not hit

          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           6 : 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           6 : 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           4 : 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          30 : 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           0 :     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           4 : 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           0 :     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      144612 :                                    "erlang-compatible garbage collector");
     132      144612 : static GCRegistry::Add<OcamlGC> B("ocaml", "ocaml 3.10-compatible GC");
     133             : static GCRegistry::Add<ShadowStackGC>
     134      144612 :     C("shadow-stack", "Very portable GC for uncooperative code generators");
     135             : static GCRegistry::Add<StatepointGC> D("statepoint-example",
     136      144612 :                                        "an example strategy for statepoint");
     137      144612 : 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      216918 : void llvm::linkCoreCLRGC() {}

Generated by: LCOV version 1.13