Add GC-Safety annotations

See #6

include/hustle/Core.hpp

@@ -51,4 +51,20 @@ static_assert(CELL_INT_MIN < 0);
 static_assert(CELL_INT_MAX > 0);
 } // namespace hustle
 
+// GC safety annotations.
+#if defined(HUSTLE_GC_SAFETY)
+#define GC_SAFETY(x) __attribute((annotate("gc::" #x)))
+#else
+#define GC_SAFETY(x)
+#endif
+
+/// Mark a function as pontentially triggering a GC
+#define HUSTLE_MAY_ALLOCATE GC_SAFETY(may_allocate)
+
+/// Mark a class as being allocated on the  GC'd heap
+#define HUSTLE_HEAP_ALLOCATED GC_SAFETY(heap_allocated)
+
+/// Marks a class as aliasing a heap pointer
+#define HUSTLE_HEAP_POINTER GC_SAFETY(heap_pointer)
+
 #endif

include/hustle/GC.hpp

@@ -97,7 +97,7 @@ class Heap {
   ~Heap() = default;
   // TODO: this should be inlined for perf, but for the moment we leave it this
   // way for flexibility
-  Object* allocate(size_t size);
+  Object* allocate(size_t size) HUSTLE_MAY_ALLOCATE;
   void gc();
 
 private:

include/hustle/Object.hpp

@@ -102,7 +102,7 @@ struct Object {
 
   // constexpr bool is_marked() const noexcept { return header.marked; }
   // constexpr void mark(bool m = true) noexcept { header.marked = m ? 1: 0;}
-};
+} HUSTLE_HEAP_ALLOCATED;
 
 #include "classes.def"
 

include/hustle/VM.hpp

@@ -64,7 +64,7 @@ struct VM {
   VM(const VM&) = delete;
   VM& operator=(const VM&) = delete;
 
-  void evaluate(Cell c);
+  void evaluate(Cell c) HUSTLE_MAY_ALLOCATE;
 
   void interpreter_loop();
   void step_hook();
@@ -75,16 +75,18 @@ struct VM {
 
   // CallStackEntry enter(Word)
 
-  void call(Cell c);
+  void call(Cell c) HUSTLE_MAY_ALLOCATE;
 
   // hack because im lazy
   template <typename T>
   void push_obj(T* o) {
     push(Cell(o));
   }
 
-  Word* register_primitive(const char* name, CallType handler);
-  void register_symbol(String* str, Quotation* quote, bool parseword = false);
+  Word* register_primitive(const char* name,
+                           CallType handler) HUSTLE_MAY_ALLOCATE;
+  void register_symbol(String* str, Quotation* quote,
+                       bool parseword = false) HUSTLE_MAY_ALLOCATE;
   void register_symbol(String* string, Word* word);
 
   cell_t lookup_symbol(const std::string& name);
@@ -103,7 +105,7 @@ struct VM {
 
   template <typename T, typename... Args>
   // std::enable_if_t<std::is_base_of_v<Object, T>, T*>
-  T* allocate(Args... args) {
+  T* allocate(Args... args) HUSTLE_MAY_ALLOCATE {
     size_t allocation_size =
         hustle::object_allocation_size<T>(std::forward<Args>(args)...);
     void* memory = heap_.allocate(allocation_size);

include/hustle/cell.hpp

@@ -28,8 +28,8 @@
 
 #ifndef HUSTLE_CELL_HPP
 #define HUSTLE_CELL_HPP
-//#include "Object.hpp"
-#include "Core.hpp"
+
+#include <hustle/Core.hpp>
 #include <hustle/Support/Assert.hpp>
 #include <type_traits>
 
@@ -169,7 +169,7 @@ class Cell {
 protected:
   explicit constexpr Cell(cell_t cell) noexcept : raw_(cell) {}
   cell_t raw_ = 0;
-};
+} HUSTLE_HEAP_POINTER;
 
 // constexpr TypedCell<intptr_t> operator"" _c(intptr_t x) { return
 // Cell::from_int(x); }
@@ -211,7 +211,7 @@ class TypedCell : public Cell {
   }
   // operator Cell() { return Cell(raw_); }
   // constexpr operator cell_t() noexcept { return raw_; }
-};
+} HUSTLE_HEAP_POINTER;
 
 } // namespace hustle
 

utils/hustlegen/classes.cpp

@@ -137,7 +137,7 @@ static void print_class_defs(IndentingStream& out, const ClassList& classes) {
     }
 
     out.outdent();
-    out.writeln("}};\n");
+    out.writeln("}} HUSTLE_HEAP_ALLOCATED;\n");
   }
 }