Lines Matching refs:collector
13 garbage collector.** You must provide your own.
18 First, you should pick a collector strategy. LLVM includes a number of built
20 Note that the collector strategy is a description of how LLVM should generate
21 code such that it interacts with your collector and runtime, not a description
22 of the collector itself.
24 Next, mark your generated functions as using your chosen collector strategy.
29 F.setGC(<collector description name>);
36 define void @foo() gc "<collector description name>" { ... }
43 barriers. If you collector does not require such barriers, you can skip
46 * Use the memory allocation routines provided by your garbage collector's
49 * If your collector requires them, generate type maps according to your
54 * Insert any coordination code required for interacting with your collector.
59 You will need to identify roots (i.e. references to heap objects your collector
61 your final stack maps. Depending on the collector strategy chosen, this is
89 compiler. The `Boehm collector
91 state-of-the-art conservative collector.
101 conservative garbage collector cannot *know* that a particular word in the
122 <gc_intrinsics>` that offer support for a broad class of collector models. For
143 Note that LLVM **does not itself provide a garbage collector** --- this should
162 references within the stack frame must be identified so that the collector may
188 language. We try to mitigate this by providing built in collector strategy
189 descriptions that can work with many common collector designs and easy
191 you need to support, we recommend trying to use one of these built in collector
215 of GCStrategy. Some collector strategies are built in. You can add others
257 address. If your target collector uses tags, use a null pointer for metadata.
343 (although a particular :ref:`collector strategy <plugin>` might). However, it
344 would be an unusual collector that violated it.
347 require the corresponding barrier. The GC strategy used with such a collector
399 To use this collector strategy, mark your functions with:
421 of :ref:`more advanced GC features <collector-algos>` of LLVM in order to
426 collector or building atop ``malloc`` are great places to start, and can be
563 You should be able to leverage any existing collector library that includes the following elements:
579 #. If you collector requires them, an LLVM IR implementation of your collectors
585 Implementing a collector plugin
594 uncontroversial collector, all that remains may be to compile LLVM's computed
599 garbage collector itself. That code should exist in the language's runtime
623 X("mygc", "My bespoke garbage collector.");
626 This boilerplate collector does nothing. More specifically:
664 It is also possible to statically link the collector plugin into tools, such as
753 When the heap is exhausted, the collector marks reachable objects starting
757 As reachability analysis proceeds, the collector copies objects from one heap
764 the properties of a copying collector (regardless of whether the mature heap
768 Denotes a multithreaded mutator; the collector must still stop the mutator
775 In this technique, the mutator and the collector run concurrently, with the
776 goal of eliminating pause times. In a *cooperative* collector, the mutator
834 for collector plugins which implement reference counting or a shadow stack.
860 flags allow the collector to perform arbitrary transformations of the
895 /// PointKind - The type of a collector-safe point.
905 A collector can request any combination of the four by setting the
932 Almost every collector requires ``PostCall`` safe points, since these correspond
988 X("mygc", "My bespoke garbage collector.");
991 The collector should use ``AsmPrinter`` to print portable assembly code. The
992 collector itself contains the stack map for the entire module, and may access