Evacuate set and map iterators during garbage collection

CMakeLists.txt

@@ -207,6 +207,8 @@ set(STRINGBUFFER_LAYOUT 6)
 set(BOOL_LAYOUT 7)
 set(SYMBOL_LAYOUT 8)
 set(VARIABLE_LAYOUT 9)
+set(SETITER_LAYOUT 11)
+set(MAPITER_LAYOUT 12)
 
 get_filename_component(INSTALL_DIR_ABS_PATH "${CMAKE_INSTALL_PREFIX}"
                        REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")

config/macros.h

@@ -21,6 +21,8 @@
 #define BOOL_LAYOUT @BOOL_LAYOUT@
 #define SYMBOL_LAYOUT @SYMBOL_LAYOUT@
 #define VARIABLE_LAYOUT @VARIABLE_LAYOUT@
+#define SETITER_LAYOUT @SETITER_LAYOUT@
+#define MAPITER_LAYOUT @MAPITER_LAYOUT@
 
 #define STRINGIFY(x) #x
 #define TOSTRING(X) STRINGIFY(X)

include/kllvm/ast/AST.h

@@ -107,7 +107,9 @@ enum class SortCategory {
   Bool,
   Symbol,
   Variable,
-  MInt
+  MInt,
+  SetIterator,
+  MapIterator,
 };
 
 // represents the syntactic category of an LLVM backend term at runtime

include/kllvm/codegen/Decision.h

@@ -366,7 +366,6 @@ class Decision {
   llvm::LLVMContext &Ctx;
   ValueType Cat;
   llvm::PHINode *FailSubject, *FailPattern, *FailSort;
-  llvm::Value *ResultBuffer, *ResultCount, *ResultCapacity;
 
   std::map<var_type, llvm::AllocaInst *> symbols;
 
@@ -383,9 +382,7 @@ class Decision {
       llvm::BasicBlock *FailureBlock, llvm::IndirectBrInst *FailJump,
       llvm::AllocaInst *ChoiceBuffer, llvm::AllocaInst *ChoiceDepth,
       llvm::Module *Module, ValueType Cat, llvm::PHINode *FailSubject,
-      llvm::PHINode *FailPattern, llvm::PHINode *FailSort,
-      llvm::Value *ResultBuffer, llvm::Value *ResultCount,
-      llvm::Value *ResultCapacity)
+      llvm::PHINode *FailPattern, llvm::PHINode *FailSort)
       : Definition(Definition)
       , CurrentBlock(EntryBlock)
       , FailureBlock(FailureBlock)
@@ -398,10 +395,7 @@ class Decision {
       , Cat(Cat)
       , FailSubject(FailSubject)
       , FailPattern(FailPattern)
-      , FailSort(FailSort)
-      , ResultBuffer(ResultBuffer)
-      , ResultCount(ResultCount)
-      , ResultCapacity(ResultCapacity) { }
+      , FailSort(FailSort) { }
 
   /* adds code to the specified basic block to take a single step based on
      the specified decision tree and return the result of taking that step. */

include/runtime/collect.h

@@ -44,6 +44,8 @@ void migrate_once(block **);
 void migrate_list(void *l);
 void migrate_map(void *m);
 void migrate_set(void *s);
+void evacuate_setiter(void *s);
+void evacuate_mapiter(void *s);
 void migrate_collection_node(void **nodePtr);
 void setKoreMemoryFunctionsForGMP(void);
 void koreCollect(void);

lib/ast/AST.cpp

@@ -220,6 +220,8 @@ std::string KORESymbol::layoutString(KOREDefinition *definition) const {
       result.append("_" + std::to_string(cat.bits) + "_");
     case SortCategory::Symbol: result.push_back('0'); break;
     case SortCategory::Uncomputed: abort();
+    case SortCategory::SetIterator: abort();
+    case SortCategory::MapIterator: abort();
     }
   }
   return result;

lib/codegen/CreateTerm.cpp

@@ -64,7 +64,8 @@ target triple = "x86_64-unknown-linux-gnu"
 %stringbuffer = type { i64, i64, %string* } ; 10-bit layout, 4-bit gc flags, 10 unused bits, 40-bit length, string length, current contents
 %map = type { { i8 *, i64 } } ; immer::map
 %set = type { { i8 *, i64 } } ; immer::set
-%iter = type { { i8 *, i8 *, i32, [14 x i8**] }, { { i8 *, i64 } } } ; immer::map_iter / immer::set_iter
+%setiter = type { { i8 *, i8 *, i32, [14 x i8**] }, { { i8 *, i64 } } } ; immer::set_iter
+%mapiter = type { { i8 *, i8 *, i32, [14 x i8**] }, { { i8 *, i64 } } } ; immer::map_iter
 %list = type { { i64, i32, i8 *, i8 * } } ; immer::flex_vector
 %mpz = type { i32, i32, i64 * } ; mpz_t
 %mpz_hdr = type { %blockheader, %mpz } ; 10-bit layout, 4-bit gc flags, 10 unused bits, 40-bit length, mpz_t
@@ -137,6 +138,8 @@ void addKompiledDirSymbol(
 static std::string MAP_STRUCT = "map";
 static std::string LIST_STRUCT = "list";
 static std::string SET_STRUCT = "set";
+static std::string SETITER_STRUCT = "setiter";
+static std::string MAPITER_STRUCT = "mapiter";
 static std::string INT_WRAPPER_STRUCT = "mpz_hdr";
 static std::string INT_STRUCT = "mpz";
 static std::string FLOAT_WRAPPER_STRUCT = "floating_hdr";
@@ -148,6 +151,8 @@ static std::string BLOCKHEADER_STRUCT = "blockheader";
 llvm::Type *getParamType(ValueType sort, llvm::Module *Module) {
   llvm::Type *type = getValueType(sort, Module);
   switch (sort.cat) {
+  case SortCategory::SetIterator:
+  case SortCategory::MapIterator:
   case SortCategory::Map:
   case SortCategory::List:
   case SortCategory::Set: type = llvm::PointerType::get(type, 1); break;
@@ -161,6 +166,8 @@ llvm::Type *getValueType(ValueType sort, llvm::Module *Module) {
   case SortCategory::Map: return getTypeByName(Module, MAP_STRUCT);
   case SortCategory::List: return getTypeByName(Module, LIST_STRUCT);
   case SortCategory::Set: return getTypeByName(Module, SET_STRUCT);
+  case SortCategory::SetIterator: return getTypeByName(Module, SETITER_STRUCT);
+  case SortCategory::MapIterator: return getTypeByName(Module, MAPITER_STRUCT);
   case SortCategory::Int:
     return llvm::PointerType::get(getTypeByName(Module, INT_STRUCT), 1);
   case SortCategory::Float:
@@ -340,6 +347,8 @@ llvm::Value *CreateTerm::createToken(ValueType sort, std::string contents) {
   case SortCategory::Map:
   case SortCategory::List:
   case SortCategory::Set:
+  case SortCategory::SetIterator:
+  case SortCategory::MapIterator:
     assert(false && "cannot create tokens of collection category");
   case SortCategory::Int: {
     llvm::Constant *global = Module->getOrInsertGlobal(

lib/codegen/Debug.cpp

@@ -180,6 +180,8 @@ llvm::DIType *getDebugType(ValueType type, std::string typeName) {
     types[typeName] = symbol;
     return symbol;
   case SortCategory::Uncomputed: abort();
+  case SortCategory::SetIterator: abort();
+  case SortCategory::MapIterator: abort();
   }
 }
 

lib/codegen/Decision.cpp

@@ -394,8 +394,13 @@ void MakeIteratorNode::codegen(Decision *d) {
   llvm::Value *arg = d->load(std::make_pair(collection, collectionType));
   args.push_back(arg);
   types.push_back(arg->getType());
-  llvm::Type *sretType = getTypeByName(d->Module, "iter");
-  llvm::Value *AllocSret = allocateTermNoReloc(sretType, d->CurrentBlock);
+  llvm::Type *sretType = type->getPointerElementType();
+  assert(hookName == "set_iterator" || hookName == "map_iterator");
+  llvm::Value *AllocSret = allocateTerm(
+      {hookName == "set_iterator" ? SortCategory::SetIterator
+                                  : SortCategory::MapIterator,
+       0},
+      sretType, d->CurrentBlock, "koreAllocAlwaysGC");
   AllocSret->setName(name.substr(0, max_name_length));
   args.insert(args.begin(), AllocSret);
   types.insert(types.begin(), AllocSret->getType());
@@ -474,14 +479,8 @@ void LeafNode::codegen(Decision *d) {
         getOrInsertFunction(
             d->Module, "addSearchResult",
             llvm::FunctionType::get(
-                llvm::Type::getVoidTy(d->Ctx),
-                {type,
-                 llvm::PointerType::getUnqual(llvm::PointerType::get(type, 1)),
-                 llvm::Type::getInt64PtrTy(d->Ctx),
-                 llvm::Type::getInt64PtrTy(d->Ctx)},
-                false)),
-        {Call, d->ResultBuffer, d->ResultCount, d->ResultCapacity}, "",
-        d->CurrentBlock);
+                llvm::Type::getVoidTy(d->Ctx), {type}, false)),
+        {Call}, "", d->CurrentBlock);
     setDebugLoc(Call2);
     if (child != FailNode::get()) {
       child->codegen(d);
@@ -646,7 +645,7 @@ void makeEvalOrAnywhereFunction(
   int i = 0;
   Decision codegen(
       definition, block, fail, jump, choiceBuffer, choiceDepth, module,
-      returnSort, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
+      returnSort, nullptr, nullptr, nullptr);
   for (auto val = matchFunc->arg_begin(); val != matchFunc->arg_end();
        ++val, ++i) {
     val->setName("_" + std::to_string(i + 1));
@@ -798,16 +797,14 @@ void makeStepFunction(
     KOREDefinition *definition, llvm::Module *module, DecisionNode *dt,
     bool search) {
   auto blockType = getValueType({SortCategory::Symbol, 0}, module);
-  auto bufType = llvm::PointerType::get(blockType, 1);
   auto debugType
       = getDebugType({SortCategory::Symbol, 0}, "SortGeneratedTopCell{}");
   llvm::FunctionType *funcType;
   std::string name;
   if (search) {
     name = "stepAll";
     funcType = llvm::FunctionType::get(
-        bufType, {blockType, llvm::Type::getInt64PtrTy(module->getContext())},
-        false);
+        llvm::Type::getVoidTy(module->getContext()), {blockType}, false);
   } else {
     name = "step";
     funcType = llvm::FunctionType::get(blockType, {blockType}, false);
@@ -817,10 +814,7 @@ void makeStepFunction(
   resetDebugLoc();
   if (search) {
     initDebugFunction(
-        name, name,
-        getDebugFunctionType(
-            getPointerDebugType(debugType, "block **"),
-            {debugType, getPointerDebugType(getLongDebugType(), "uint64_t *")}),
+        name, name, getDebugFunctionType(getVoidDebugType(), {debugType}),
         definition, matchFunc);
   } else {
     initDebugFunction(
@@ -841,30 +835,8 @@ void makeStepFunction(
   llvm::AllocaInst *choiceBuffer, *choiceDepth;
   llvm::IndirectBrInst *jump;
 
-  llvm::Value *resultBuffer = nullptr, *resultCount = nullptr,
-              *resultCapacity = nullptr;
-  if (search) {
-    resultBuffer = new llvm::AllocaInst(bufType, 0, "resultBuffer", block);
-    resultCount = matchFunc->arg_begin() + 1;
-    resultCapacity = new llvm::AllocaInst(
-        llvm::Type::getInt64Ty(module->getContext()), 0, "resultCapacity",
-        block);
-  }
-
   insertCallToClear(block);
 
-  if (search) {
-    llvm::Value *initialBuffer = allocateTerm(
-        {SortCategory::Symbol, 0}, blockType, block, "koreAllocAlwaysGC");
-    new llvm::StoreInst(initialBuffer, resultBuffer, block);
-    new llvm::StoreInst(
-        llvm::ConstantInt::get(llvm::Type::getInt64Ty(module->getContext()), 0),
-        resultCount, block);
-    new llvm::StoreInst(
-        llvm::ConstantInt::get(llvm::Type::getInt64Ty(module->getContext()), 1),
-        resultCapacity, block);
-  }
-
   initChoiceBuffer(
       dt, module, block, pre_stuck, fail, &choiceBuffer, &choiceDepth, &jump);
 
@@ -877,12 +849,10 @@ void makeStepFunction(
   val->setName("_1");
   Decision codegen(
       definition, result, fail, jump, choiceBuffer, choiceDepth, module,
-      {SortCategory::Symbol, 0}, nullptr, nullptr, nullptr, resultBuffer,
-      resultCount, resultCapacity);
+      {SortCategory::Symbol, 0}, nullptr, nullptr, nullptr);
   codegen.store(std::make_pair(val->getName().str(), val->getType()), val);
   if (search) {
-    auto result = new llvm::LoadInst(bufType, resultBuffer, "", stuck);
-    llvm::ReturnInst::Create(module->getContext(), result, stuck);
+    llvm::ReturnInst::Create(module->getContext(), stuck);
   } else {
     llvm::ReturnInst::Create(module->getContext(), val, stuck);
   }
@@ -949,8 +919,7 @@ void makeMatchReasonFunction(
   val->setName("_1");
   Decision codegen(
       definition, block, fail, jump, choiceBuffer, choiceDepth, module,
-      {SortCategory::Symbol, 0}, FailSubject, FailPattern, FailSort, nullptr,
-      nullptr, nullptr);
+      {SortCategory::Symbol, 0}, FailSubject, FailPattern, FailSort);
   codegen.store(std::make_pair(val->getName().str(), val->getType()), val);
   llvm::ReturnInst::Create(module->getContext(), stuck);
 
@@ -1065,8 +1034,7 @@ void makeStepFunction(
   i = 0;
   Decision codegen(
       definition, header, fail, jump, choiceBuffer, choiceDepth, module,
-      {SortCategory::Symbol, 0}, nullptr, nullptr, nullptr, nullptr, nullptr,
-      nullptr);
+      {SortCategory::Symbol, 0}, nullptr, nullptr, nullptr);
   for (auto val : args) {
     val->setName(res.residuals[i].occurrence.substr(0, max_name_length));
     codegen.store(std::make_pair(val->getName().str(), val->getType()), val);

lib/codegen/DecisionParser.cpp

@@ -197,27 +197,36 @@ class DTPreprocessor {
 
   DecisionNode *makeIterator(yaml_node_t *node) {
     std::string name = to_string(vec(get(node, "collection")));
-    llvm::Type *type = getParamType(
-        KORECompositeSort::getCategory(str(get(node, "sort"))), mod);
+    std::string cat = str(get(node, "sort"));
+    llvm::Type *type = getParamType(KORECompositeSort::getCategory(cat), mod);
     std::string function = str(get(node, "function"));
     auto child = (*this)(get(node, "next"));
 
+    assert(cat == "SET.Set" || cat == "MAP.Map");
+
     return MakeIteratorNode::Create(
         name, type, name + "_iter",
-        llvm::PointerType::getUnqual(getTypeByName(mod, "iter")), function,
-        child);
+        llvm::PointerType::get(
+            getTypeByName(mod, cat == "SET.Set" ? "setiter" : "mapiter"), 1),
+        function, child);
   }
 
   DecisionNode *iterNext(yaml_node_t *node) {
     std::string iterator = to_string(vec(get(node, "iterator"))) + "_iter";
     std::string name = to_string(vec(get(node, "binding")));
-    llvm::Type *type = getParamType(
-        KORECompositeSort::getCategory(str(get(node, "sort"))), mod);
+    std::string cat = str(get(node, "sort"));
+    llvm::Type *type = getParamType(KORECompositeSort::getCategory(cat), mod);
     std::string function = str(get(node, "function"));
     auto child = (*this)(get(node, "next"));
 
+    assert(function == "set_iterator_next" || function == "map_iterator_next");
+
     return IterNextNode::Create(
-        iterator, llvm::PointerType::getUnqual(getTypeByName(mod, "iter")),
+        iterator,
+        llvm::PointerType::get(
+            getTypeByName(
+                mod, function == "set_iterator_next" ? "setiter" : "mapiter"),
+            1),
         name, type, function, child);
   }
 

lib/codegen/EmitConfigParser.cpp

@@ -306,6 +306,8 @@ static llvm::Value *getArgValue(
         CaseBlock);
     break;
   case SortCategory::Uncomputed: abort();
+  case SortCategory::MapIterator: abort();
+  case SortCategory::SetIterator: abort();
   }
   return arg;
 }
@@ -362,6 +364,8 @@ static std::pair<llvm::Value *, llvm::BasicBlock *> getEval(
     break;
   }
   case SortCategory::Uncomputed: abort();
+  case SortCategory::MapIterator: abort();
+  case SortCategory::SetIterator: abort();
   }
   creator.getCurrentBlock()->getInstList().push_back(inst);
   return std::make_pair(retval, creator.getCurrentBlock());
@@ -590,6 +594,8 @@ static void emitGetToken(KOREDefinition *definition, llvm::Module *module) {
     case SortCategory::Variable:
     case SortCategory::Symbol: break;
     case SortCategory::Uncomputed: abort();
+    case SortCategory::MapIterator: abort();
+    case SortCategory::SetIterator: abort();
     }
     CurrentBlock = FalseBlock;
   }
@@ -981,6 +987,8 @@ static void getVisitor(
       break;
     }
     case SortCategory::Uncomputed: abort();
+    case SortCategory::MapIterator: abort();
+    case SortCategory::SetIterator: abort();
     }
     if (i != symbol->getArguments().size() - 1) {
       llvm::CallInst::Create(

lib/llvm/EmitGCLayoutInfo.cpp

@@ -74,6 +74,10 @@ struct EmitGCLayoutInfo : public ModulePass {
                 cat.cat = SortCategory::List;
               } else if (name == "set") {
                 cat.cat = SortCategory::Set;
+              } else if (name == "setiter") {
+                cat.cat = SortCategory::SetIterator;
+              } else if (name == "mapiter") {
+                cat.cat = SortCategory::SetIterator;
               } else if (name == "mpz") {
                 cat.cat = SortCategory::Int;
               } else if (name == "floating") {

runtime/alloc/alloc.cpp

@@ -100,6 +100,16 @@ koreAllocAlwaysGC_p1s_lists(size_t requested) {
   return (list *)koreAllocAlwaysGC(requested);
 }
 
+__attribute__((always_inline)) setiter *
+koreAllocAlwaysGC_p1s_setiters(size_t requested) {
+  return (setiter *)koreAllocAlwaysGC(requested);
+}
+
+__attribute__((always_inline)) mapiter *
+koreAllocAlwaysGC_p1s_mapiters(size_t requested) {
+  return (mapiter *)koreAllocAlwaysGC(requested);
+}
+
 __attribute__((always_inline)) block *
 koreAllocAlwaysGC_p1s_blocks(size_t requested) {
   return (block *)koreAllocAlwaysGC(requested);