add flag to control whether gc should be enabled or not

include/kllvm/codegen/CreateTerm.h

@@ -35,6 +35,8 @@ class create_term {
   bool populate_static_set(kore_pattern *pattern);
   std::pair<llvm::Value *, bool> create_allocation(
       kore_pattern *pattern, std::string const &location_stack = "");
+  llvm::Value *disable_gc();
+  void enable_gc(llvm::Value *was_enabled);
 
 public:
   create_term(

include/runtime/header.h

@@ -111,6 +111,8 @@ size_t hash_k(block *);
 void k_hash(block *, void *);
 bool hash_enter(void);
 void hash_exit(void);
+
+extern bool gc_enabled;
 }
 
 __attribute__((always_inline)) constexpr uint64_t len_hdr(uint64_t hdr) {
@@ -225,7 +227,10 @@ struct kore_alloc_heap {
     if (during_gc()) {
       return ::operator new(size);
     }
+    bool enabled = gc_enabled;
+    gc_enabled = false;
     auto *result = (string *)kore_alloc_token(size + sizeof(blockheader));
+    gc_enabled = enabled;
     init_with_len(result, size);
     return result->data;
   }

lib/codegen/CreateTerm.cpp

@@ -673,8 +673,29 @@ llvm::Value *create_term::create_hook(
   }
   std::string hook_name = "hook_" + name.substr(0, name.find('.')) + "_"
                           + name.substr(name.find('.') + 1);
-  return create_function_call(
+  auto *old_val = disable_gc();
+  auto *result = create_function_call(
       hook_name, pattern, true, false, true, location_stack);
+  enable_gc(old_val);
+  return result;
+}
+
+llvm::Value *create_term::disable_gc() {
+  llvm::Constant *global
+      = module_->getOrInsertGlobal("gc_enabled", llvm::Type::getInt1Ty(ctx_));
+  auto *global_var = llvm::cast<llvm::GlobalVariable>(global);
+  auto *old_val = new llvm::LoadInst(
+      llvm::Type::getInt1Ty(ctx_), global_var, "was_enabled", current_block_);
+  new llvm::StoreInst(
+      llvm::ConstantInt::getFalse(ctx_), global_var, current_block_);
+  return old_val;
+}
+
+void create_term::enable_gc(llvm::Value *was_enabled) {
+  llvm::Constant *global
+      = module_->getOrInsertGlobal("gc_enabled", llvm::Type::getInt1Ty(ctx_));
+  auto *global_var = llvm::cast<llvm::GlobalVariable>(global);
+  new llvm::StoreInst(was_enabled, global_var, current_block_);
 }
 
 // We use tailcc calling convention for apply_rule_* and eval_* functions to

runtime/alloc/alloc.cpp

@@ -113,13 +113,19 @@ kore_resize_last_alloc(void *oldptr, size_t newrequest, size_t last_size) {
 }
 
 void *kore_alloc_mp(size_t requested) {
+  bool enabled = gc_enabled;
+  gc_enabled = false;
   auto *new_token = (string *)kore_alloc_token(sizeof(string) + requested);
+  gc_enabled = enabled;
   init_with_len(new_token, requested);
   return new_token->data;
 }
 
 void *kore_realloc_mp(void *ptr, size_t old_size, size_t new_size) {
+  bool enabled = gc_enabled;
+  gc_enabled = false;
   auto *new_token = (string *)kore_alloc_token(sizeof(string) + new_size);
+  gc_enabled = enabled;
   size_t min = old_size > new_size ? new_size : old_size;
   memcpy(new_token->data, ptr, min);
   init_with_len(new_token, new_size);

runtime/alloc/arena.cpp

@@ -116,6 +116,8 @@ static void fresh_block(struct arena *arena) {
       BLOCK_SIZE - sizeof(memory_block_header));
 }
 
+bool gc_enabled;
+
 static __attribute__((noinline)) void *
 do_alloc_slow(size_t requested, struct arena *arena) {
   MEM_LOG(

runtime/util/ConfigurationParser.cpp

@@ -98,6 +98,7 @@ struct construction {
 
 // NOLINTNEXTLINE(*-cognitive-complexity)
 extern "C" void *construct_initial_configuration(kore_pattern const *initial) {
+  gc_enabled = false;
   std::vector<std::variant<kore_pattern const *, construction>> work_list{
       initial};
   std::vector<void *> output;
@@ -156,13 +157,15 @@ extern "C" void *construct_initial_configuration(kore_pattern const *initial) {
     }
   }
 
+  gc_enabled = true;
   return output[0];
 }
 
 // NOLINTBEGIN(*-cognitive-complexity)
 template <typename It>
 static void *
 deserialize_initial_configuration(It ptr, It end, binary_version version) {
+  gc_enabled = false;
   using namespace kllvm::detail;
   auto begin = ptr;
 
@@ -253,6 +256,7 @@ deserialize_initial_configuration(It ptr, It end, binary_version version) {
     }
   }
 
+  gc_enabled = true;
   assert(output.size() == 1 && "Output stack left in invalid state");
   return output.front();
 }

unittests/runtime-collections/lists.cpp

@@ -63,6 +63,8 @@ block D1 = {{1}};
 block *DUMMY1 = &D1;
 }
 
+bool gc_enabled;
+
 BOOST_AUTO_TEST_SUITE(ListTest)
 
 BOOST_AUTO_TEST_CASE(element) {