lcb: Implemented pointer type for store intrinsics

vadl/main/resources/templates/lcb/clang/lib/CodeGen/CGBuiltin.cpp

@@ -6340,6 +6340,28 @@ Value *CodeGenFunction::Emit[(${namespace})]BuiltinExpr(unsigned BuiltinID,
     Ops.push_back(EmitScalarOrConstFoldImmArg(ICEArguments, i, E));
   }
 
+  switch (BuiltinID) {
+  [#th:block th:each="builtin : ${builtins}" ]
+  [# th:if="${builtin.writesMem}" ]
+  case [(${namespace})]::[(${builtin.builtin})]: {
+    QualType PointeeType = E->getArg(0)->getType()->getPointeeType();
+    auto *StoreAddress = Ops[0];
+    if (Ops.size() > 2) {
+      StoreAddress = Builder.CreateGEP(Builder.getInt8Ty(), StoreAddress, Ops[2]);
+    }
+
+    auto ValueType = ConvertType(PointeeType);
+    auto *StoreValue = Builder.CreateIntCast(
+        Ops[1], ValueType, E->getArg(1)->getType()->isSignedIntegerOrEnumerationType());
+    auto StoreLValue = MakeNaturalAlignPointeeAddrLValue(StoreAddress, PointeeType);
+    return Builder.CreateStore(StoreValue, StoreLValue.getAddress());
+  }
+  [/]
+  [/th:block]
+  default:
+    break;
+  }
+
   // Required for overloaded intrinsics.
   llvm::SmallVector<llvm::Type *, 2> IntrinsicTypes;
   switch (BuiltinID) {

vadl/main/vadl/lcb/template/clang/include/Basic/EmitBuiltinsTableGenPass.java

@@ -36,7 +36,13 @@
 import vadl.lcb.template.LcbTemplateRenderingPass;
 import vadl.pass.PassResults;
 import vadl.template.Renderable;
+import vadl.types.Type;
+import vadl.viam.Instruction;
 import vadl.viam.Specification;
+import vadl.viam.graph.Graph;
+import vadl.viam.graph.dependency.ReadMemNode;
+import vadl.viam.graph.dependency.WriteMemNode;
+import vadl.viam.passes.SnapshotInstructionBehaviorPass;
 
 /**
  * This file contains the tablegen setup for builtins.
@@ -76,28 +82,46 @@ protected Map<String, Object> createVariables(PassResults passResults,
             GenerateTableGenMachineInstructionRecordPass.class);
     var output = (GenerateGcbIntrinsicsPass.Output) passResults.lastResultOf(
         GenerateGcbIntrinsicsPass.class);
+    var snapshots =
+        (Map<Instruction, Graph>) passResults.lastResultOf(SnapshotInstructionBehaviorPass.class);
     return Map.of(CommonVarNames.NAMESPACE,
         lcbConfiguration().targetName().value().toLowerCase(),
-        "builtins", createBuiltins(output, machineRecords));
+        "builtins", createBuiltins(output, machineRecords, snapshots));
   }
 
   private List<Builtin> createBuiltins(GenerateGcbIntrinsicsPass.Output output,
-                                       List<TableGenMachineInstruction> records) {
+                                       List<TableGenMachineInstruction> records,
+                                       Map<Instruction, Graph> snapshots) {
     var lookup = records.stream().collect(Collectors.toMap(
         TableGenMachineInstruction::instruction, x -> x));
     return output.intrinsics().stream()
         .map(intrinsic -> {
           var record = Objects.requireNonNull(lookup.get(intrinsic.instruction()));
+          var snapshot = Objects.requireNonNull(snapshots.get(intrinsic.instruction()));
           var returnTy = mapTy(record.getOutOperands().stream().findFirst());
-          var paramsTy = record.getInOperands().stream().map(this::mapTy).toList();
+          var paramsTy = record.getInOperands().stream()
+              .map(operand -> mapTy(Optional.of(operand)))
+              .collect(Collectors.toCollection(java.util.ArrayList::new));
+          pointerType(snapshot).ifPresent(pointerTy -> paramsTy.set(0, pointerTy));
           var prototype = new Prototype(returnTy, paramsTy);
           return new Builtin(intrinsic.builtinName(), prototype);
         })
         .toList();
   }
 
-  private String mapTy(GcbInstructionOperand operand) {
-    return mapTy(Optional.of(operand));
+  private Optional<String> pointerType(Graph snapshot) {
+    var readMem = snapshot.getNodes(ReadMemNode.class).findFirst();
+    if (readMem.isPresent()) {
+      return Optional.of(mapPointerTy(readMem.get().readBitWidth()));
+    }
+
+    var writeMem = snapshot.getNodes(WriteMemNode.class).findFirst();
+    return writeMem.map(write -> mapPointerTy(write.writeBitWidth()));
+  }
+
+  private String mapPointerTy(int bitWidth) {
+    return CppTypeMap.getCppBuiltinTypeNameByVadlType(ValueType.from(
+        Type.unsignedInt(bitWidth)).orElseThrow()) + "*";
   }
 
   private String mapTy(Optional<GcbInstructionOperand> operand) {

vadl/main/vadl/lcb/template/clang/lib/CodeGen/EmitCGBuiltinFilePass.java

@@ -17,13 +17,20 @@
 package vadl.lcb.template.clang.lib.CodeGen;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
 import vadl.configuration.LcbConfiguration;
 import vadl.gcb.passes.GenerateGcbIntrinsicsPass;
+import vadl.gcb.passes.InstructionIntrinsicAttributesCtx;
+import vadl.lcb.passes.llvmLowering.GenerateTableGenMachineInstructionRecordPass;
+import vadl.lcb.passes.llvmLowering.tablegen.model.TableGenMachineInstruction;
 import vadl.lcb.template.CommonVarNames;
 import vadl.lcb.template.LcbTemplateRenderingPass;
 import vadl.pass.PassResults;
 import vadl.template.Renderable;
+import vadl.viam.Instruction;
 import vadl.viam.Specification;
 
 /**
@@ -46,11 +53,12 @@ protected String getOutputPath() {
     return "clang/lib/CodeGen/CGBuiltin.cpp";
   }
 
-  private record Intrinsic(String builtin, String intrinsic) implements Renderable {
+  private record Intrinsic(String builtin, String intrinsic, boolean writesMem)
+      implements Renderable {
 
     @Override
     public Map<String, Object> renderObj() {
-      return Map.of("builtin", builtin, "intrinsic", intrinsic);
+      return Map.of("builtin", builtin, "intrinsic", intrinsic, "writesMem", writesMem);
     }
   }
 
@@ -59,13 +67,21 @@ protected Map<String, Object> createVariables(final PassResults passResults,
                                                 Specification specification) {
     var output = (GenerateGcbIntrinsicsPass.Output) passResults.lastResultOf(
         GenerateGcbIntrinsicsPass.class);
+    var records = ((List<TableGenMachineInstruction>) passResults.lastResultOf(
+        GenerateTableGenMachineInstructionRecordPass.class)).stream().collect(Collectors.toMap(
+        TableGenMachineInstruction::instruction, x -> x));
     var namespace = lcbConfiguration().targetName().value().toLowerCase();
     return Map.of(CommonVarNames.NAMESPACE, namespace,
         "builtins",
         output.intrinsics()
             .stream()
-            .map(x -> new Intrinsic("BI" + namespace + "_" + x.builtinName(),
-                x.intrinsicName()))
+            .map(x -> {
+              Objects.requireNonNull(records.get(x.instruction()));
+              return new Intrinsic("BI" + namespace + "_" + x.builtinName(),
+                  x.intrinsicName(),
+                  x.intrinsicAttributes().contains(
+                      InstructionIntrinsicAttributesCtx.Attribute.WriteMem));
+            })
             .toList());
   }
 }

vadl/main/vadl/lcb/template/lib/IR/EmitMiddleendIntrinsicsTableGenPass.java

@@ -46,6 +46,10 @@
 import vadl.utils.SourceLocation;
 import vadl.viam.Instruction;
 import vadl.viam.Specification;
+import vadl.viam.graph.Graph;
+import vadl.viam.graph.dependency.ReadMemNode;
+import vadl.viam.graph.dependency.WriteMemNode;
+import vadl.viam.passes.SnapshotInstructionBehaviorPass;
 
 /**
  * Tablegen to generate middleend intrinsics.
@@ -68,11 +72,13 @@ protected Map<String, Object> createVariables(PassResults passResults,
         (GenerateGcbIntrinsicsPass.Output) passResults
             .lastResultOf(
                 GenerateGcbIntrinsicsPass.class);
+    var snapshots =
+        (Map<Instruction, Graph>) passResults.lastResultOf(SnapshotInstructionBehaviorPass.class);
     var records = ((List<TableGenMachineInstruction>) passResults.lastResultOf(
         GenerateTableGenMachineInstructionRecordPass.class)).stream().collect(Collectors.toMap(
         TableGenMachineInstruction::instruction, x -> x));
 
-    var intrinsics = genIntrinsics(output, records);
+    var intrinsics = genIntrinsics(output, records, snapshots);
 
     return Map.of(CommonVarNames.NAMESPACE,
         lcbConfiguration().targetName().value().toLowerCase(),
@@ -107,22 +113,26 @@ private String getName(InstructionIntrinsicAttributesCtx.Attribute x) {
 
   private List<Intrinsic> genIntrinsics(
       GenerateGcbIntrinsicsPass.Output output,
-      Map<Instruction, TableGenMachineInstruction> records) {
+      Map<Instruction, TableGenMachineInstruction> records,
+      Map<Instruction, Graph> snapshots) {
     var result = new ArrayList<Intrinsic>();
 
     for (var intrinsic : output.intrinsics()) {
       var instruction = intrinsic.instruction();
       var attrs = intrinsic.intrinsicAttributes();
       var record = ensureNonNull(records.get(instruction), "must not be null");
+      var snapshot = ensureNonNull(snapshots.get(instruction), "must not be null");
+      var paramTypes = record.getInOperands().stream().map(this::mapParam)
+          .filter(Optional::isPresent)
+          .map(Optional::get)
+          .collect(Collectors.toCollection(ArrayList::new));
+      pointerType(snapshot).ifPresent(pointerTy -> paramTypes.set(0, pointerTy));
 
       var lcbIntrinsic =
           new Intrinsic(
               intrinsic.intrinsicName(),
               List.of("llvm_any_ty"),
-              record.getInOperands().stream().map(this::mapParam)
-                  .filter(Optional::isPresent)
-                  .map(Optional::get)
-                  .collect(Collectors.toList()),
+              paramTypes,
               attrs);
       result.add(lcbIntrinsic);
     }
@@ -164,6 +174,18 @@ private String mapType(DataType dataType) {
         .build();
   }
 
+  private Optional<String> pointerType(Graph snapshot) {
+    if (snapshot.getNodes(ReadMemNode.class).findFirst().isPresent()) {
+      return Optional.of("llvm_ptr_ty");
+    }
+
+    if (snapshot.getNodes(WriteMemNode.class).findFirst().isPresent()) {
+      return Optional.of("llvm_ptr_ty");
+    }
+
+    return Optional.empty();
+  }
+
   @Override
   protected String getTemplatePath() {
     return "lcb/llvm/include/llvm/IR/Intrinsics.td";

vadl/test/resources/llvm/riscv/qemu_nolibc/rv32im/builtin_load.c

@@ -1,5 +1,5 @@
 int main() {
-    int value = 42;
-    int addr = (int) &value;
+    unsigned int value = 42;
+    unsigned int *addr = &value;
     return !(rv32im_LW(addr, 0) == 42);
-}
+}

vadl/test/resources/llvm/riscv/qemu_nolibc/rv32im/builtin_store.c

@@ -1,9 +1,7 @@
 int main() {
-    /*
-    int value = 0;
-    int addr = (int) &value;
+    unsigned int value = 0;
+    unsigned int *addr = &value;
 
-    rv32im_SW(addr, 0, 42);
-    */
-    return 0; // !(value == 42);
+    rv32im_SW(addr, 42, 0);
+    return !(value == 42);
 }