Finished transition from templates to generics.

Author: Verdagon

Backend/src/function/function.cpp

@@ -239,7 +239,7 @@ void translateFunction(
     GlobalState* globalState,
     Function* functionM) {
 
-  auto functionL = globalState->getFunction(functionM->prototype->name);
+  auto functionL = globalState->getFunction(functionM->prototype);
   auto returnTypeL = globalState->getRegion(functionM->prototype->returnType)->translateType(functionM->prototype->returnType);
 
   auto localsBlockName = std::string("localsBlock");

Backend/src/globalstate.cpp

@@ -55,8 +55,8 @@ std::vector<LLVMValueRef> GlobalState::getEdgeFunctions(Edge* edge) {
   for (int i = 0; i < edge->structPrototypesByInterfaceMethod.size(); i++) {
     assert(edge->structPrototypesByInterfaceMethod[i].first == interfaceM->methods[i]);
 
-    auto funcName = edge->structPrototypesByInterfaceMethod[i].second->name;
-    auto edgeFunctionL = getFunction(funcName);
+    auto funcPrototype = edge->structPrototypesByInterfaceMethod[i].second;
+    auto edgeFunctionL = getFunction(funcPrototype);
     edgeFunctionsL.push_back(edgeFunctionL);
   }
 
@@ -133,10 +133,18 @@ IRegion* GlobalState::getRegion(RegionId* regionId) {
   }
 }
 
-LLVMValueRef GlobalState::getFunction(Name* name) {
-  auto functionIter = functions.find(name->name);
-  assert(functionIter != functions.end());
-  return functionIter->second;
+LLVMValueRef GlobalState::getFunction(Prototype* prototype) {
+  auto functionIter = functions.find(prototype->name->name);
+  if (functionIter != functions.end()) {
+    return functionIter->second;
+  }
+
+  auto extraFunctionIter = extraFunctions.find(prototype);
+  if (extraFunctionIter != extraFunctions.end()) {
+    return extraFunctionIter->second;
+  }
+
+  assert(false);
 }
 
 LLVMValueRef GlobalState::getInterfaceTablePtr(Edge* edge) {

Backend/src/globalstate.h

@@ -224,6 +224,8 @@ class GlobalState {
   Name* serializeThunkName = nullptr;
   Name* unserializeName = nullptr;
   Name* unserializeThunkName = nullptr;
+  Name* freeName = nullptr;
+  Name* freeThunkName = nullptr;
 
   RCImm* rcImm = nullptr;
   IRegion* mutRegion = nullptr;
@@ -244,7 +246,7 @@ class GlobalState {
   IRegion* getRegion(Reference* referenceM);
   IRegion* getRegion(Kind* kindM);
   IRegion* getRegion(RegionId* regionId);
-  LLVMValueRef getFunction(Name* name);
+  LLVMValueRef getFunction(Prototype* proto);
   LLVMValueRef getInterfaceTablePtr(Edge* edge);
   LLVMValueRef getOrMakeStringConstant(const std::string& str);
 };

Backend/src/metal/ast.h

@@ -45,9 +45,8 @@ class Package {
   std::unordered_map<std::string, StructDefinition*> structs;
   std::unordered_map<std::string, StaticSizedArrayDefinitionT*> staticSizedArrays;
   std::unordered_map<std::string, RuntimeSizedArrayDefinitionT*> runtimeSizedArrays;
-//  std::unordered_map<std::string, Prototype*> externs;
   std::unordered_map<std::string, Function*> functions;
-  std::unordered_map<Kind*, Prototype*, AddressHasher<Kind*>> immDestructorsByKind;
+//  std::unordered_map<Kind*, Prototype*, AddressHasher<Kind*>> immDestructorsByKind;
 
   // This only contains exports defined in this package. Though, the things they're exporting can
   // be defined somewhere else.
@@ -69,7 +68,7 @@ class Package {
     std::unordered_map<std::string, StaticSizedArrayDefinitionT*> staticSizedArrays_,
     std::unordered_map<std::string, RuntimeSizedArrayDefinitionT*> runtimeSizedArrays_,
     std::unordered_map<std::string, Function*> functions_,
-    std::unordered_map<Kind*, Prototype*, AddressHasher<Kind*>> immDestructorsByKind_,
+//    std::unordered_map<Kind*, Prototype*, AddressHasher<Kind*>> immDestructorsByKind_,
     std::unordered_map<std::string, Prototype*> exportNameToFunction_,
     std::unordered_map<std::string, Kind*> exportNameToKind_,
     std::unordered_map<std::string, Prototype*> externNameToFunction_,
@@ -80,7 +79,7 @@ class Package {
       staticSizedArrays(std::move(staticSizedArrays_)),
       runtimeSizedArrays(std::move(runtimeSizedArrays_)),
       functions(std::move(functions_)),
-      immDestructorsByKind(std::move(immDestructorsByKind_)),
+//      immDestructorsByKind(std::move(immDestructorsByKind_)),
       exportNameToFunction(std::move(exportNameToFunction_)),
       exportNameToKind(std::move(exportNameToKind_)),
       externNameToFunction(std::move(externNameToFunction_)),
@@ -173,11 +172,11 @@ class Package {
     }
     return std::optional(iter->second);
   }
-  Prototype* getImmDestructor(Kind* kind) {
-    auto iter = immDestructorsByKind.find(kind);
-    assert(iter != immDestructorsByKind.end());
-    return iter->second;
-  }
+//  Prototype* getImmDestructor(Kind* kind) {
+//    auto iter = immDestructorsByKind.find(kind);
+//    assert(iter != immDestructorsByKind.end());
+//    return iter->second;
+//  }
 
   std::string getKindExportName(Kind* kind, bool includeProjectName) const {
     if (auto innt = dynamic_cast<Int *>(kind)) {
@@ -299,9 +298,9 @@ class Program {
   RuntimeSizedArrayDefinitionT* getRuntimeSizedArray(RuntimeSizedArrayT* rsaMT) {
     return getPackage(rsaMT->name->packageCoord)->getRuntimeSizedArray(rsaMT);
   }
-  Prototype* getImmDestructor(Kind* kind) {
-    return getPackage(kind->getPackageCoordinate())->getImmDestructor(kind);
-  }
+//  Prototype* getImmDestructor(Kind* kind) {
+//    return getPackage(kind->getPackageCoordinate())->getImmDestructor(kind);
+//  }
 //  bool isExported(Name* name) {
 //    return getPackage(name->packageCoord)->isExported(name);
 //  }

Backend/src/metal/readjson.cpp

@@ -720,12 +720,12 @@ Package* readPackage(MetalCache* cache, const json& program) {
             auto f = readFunction(cache, j);
             return std::make_pair(f->prototype->name->name, f);
           }),
-      readArrayIntoMap<Kind*, Prototype*>(
-          cache,
-          AddressHasher<Kind*>(cache->addressNumberer),
-          std::equal_to<Kind*>(),
-          program["immDestructorsByKind"],
-          readKindAndPrototypeEntry),
+//      readArrayIntoMap<Kind*, Prototype*>(
+//          cache,
+//          AddressHasher<Kind*>(cache->addressNumberer),
+//          std::equal_to<Kind*>(),
+//          program["immDestructorsByKind"],
+//          readKindAndPrototypeEntry),
       readArrayIntoMap<std::string, Prototype*>(
           cache,
           std::hash<std::string>(),

Backend/src/region/linear/linearstructs.cpp

@@ -66,8 +66,9 @@ void LinearStructs::declareStruct(StructKind* structM) {
 void LinearStructs::declareEdge(StructKind* structKind, InterfaceKind* interfaceKind) {
   // There aren't edges per se, just tag numbers. That's all we have to do here.
 
-  // Creates one if it doesnt already exist.
-  auto* os = &orderedStructsByInterface[interfaceKind];
+  auto iter = orderedStructsByInterface.find(interfaceKind);
+  assert(iter != orderedStructsByInterface.end()); // declareInterface should have made it
+  auto* os = &iter->second;
 
   assert(std::count(os->begin(), os->end(), structKind) == 0);
   os->push_back(structKind);
@@ -88,6 +89,8 @@ void LinearStructs::declareInterface(InterfaceKind* interface) {
 
   interfaceRefStructsL.emplace(interface, interfaceRefStructL);
 
+  orderedStructsByInterface.emplace(interface, std::vector<StructKind*>{});
+
   // No need to make interface table structs, there are no itables for Linear.
 }