Merge pull request #68 from OpenVADL/feature/calling-convention-abi

frontend: Implement lowering of calling convention

Author: kper

vadl/main/resources/templates/lcb/llvm/lib/Target/RegisterInfo.cpp

@@ -48,7 +48,10 @@ BitVector [(${namespace})]RegisterInfo::getReservedRegs(const MachineFunction &M
     markSuperRegs(Reserved, [(${namespace})]::[(${framePointer})]); // frame pointer
     markSuperRegs(Reserved, [(${namespace})]::[(${stackPointer})]); // stack pointer
     markSuperRegs(Reserved, [(${namespace})]::[(${globalPointer})]); // global pointer
+
+    [# th:if="hasThreadPointer" ]
     markSuperRegs(Reserved, [(${namespace})]::[(${threadPointer})]); // thread pointer
+    [/]
 
     [# th:each="constraint : ${constraints}" ]
     markSuperRegs(Reserved,  [(${namespace})]::[(${constraint.registerFile})][(${constraint.index})]);

vadl/main/vadl/ast/Definition.java

@@ -3475,14 +3475,14 @@ enum SeqKind {
 class SpecialPurposeRegisterDefinition extends Definition {
 
   Purpose purpose;
-  Identifier aliasName;
+  List<SequenceCallExpr> exprs;
   SourceLocation loc;
 
   SpecialPurposeRegisterDefinition(Purpose purpose,
-                                   Identifier aliasName,
+                                   List<SequenceCallExpr> sequence,
                                    SourceLocation loc) {
     this.purpose = purpose;
-    this.aliasName = aliasName;
+    this.exprs = sequence;
     this.loc = loc;
   }
 
@@ -3507,7 +3507,9 @@ void prettyPrint(int indent, StringBuilder builder) {
     builder.append(prettyIndentString(indent));
     builder.append(purpose.keywords);
     builder.append(" = ");
-    builder.append(aliasName);
+    exprs.forEach(e -> {
+      e.prettyPrint(indent + 1, builder);
+    });
   }
 
   @Override
@@ -3519,12 +3521,18 @@ public boolean equals(Object o) {
       return false;
     }
     SpecialPurposeRegisterDefinition that = (SpecialPurposeRegisterDefinition) o;
-    return purpose == that.purpose && aliasName.equals(that.aliasName);
+    return purpose == that.purpose && Objects.equals(exprs, that.exprs);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(purpose, aliasName);
+    return Objects.hash(purpose, exprs);
+  }
+
+  enum Occurrence {
+    OPTIONAL,
+    ONE,
+    AT_LEAST_ONE
   }
 
   enum Purpose {
@@ -3543,6 +3551,41 @@ enum Purpose {
     Purpose(String keywords) {
       this.keywords = keywords;
     }
+
+    /**
+     * Determines how many arguments are allowed.
+     * function value = a{0..1} -> ok
+     * stack pointer = a{0..1} -> not ok
+     */
+    public static final Map<Purpose, Occurrence> numberOfExpectedArguments;
+
+    /**
+     * Determines how often a definition is allowed in the ABI.
+     */
+    public static final Map<Purpose, Occurrence> numberOfOccurrencesAbi;
+
+    static {
+      numberOfExpectedArguments = Map.of(Purpose.STACK_POINTER, Occurrence.ONE,
+          Purpose.RETURN_ADDRESS, Occurrence.ONE,
+          Purpose.GLOBAL_POINTER, Occurrence.ONE,
+          Purpose.FRAME_POINTER, Occurrence.ONE,
+          Purpose.THREAD_POINTER, Occurrence.ONE,
+          Purpose.RETURN_VALUE, Occurrence.AT_LEAST_ONE,
+          Purpose.CALLER_SAVED, Occurrence.AT_LEAST_ONE,
+          Purpose.CALLEE_SAVED, Occurrence.AT_LEAST_ONE,
+          Purpose.FUNCTION_ARGUMENT, Occurrence.AT_LEAST_ONE);
+
+
+      numberOfOccurrencesAbi = Map.of(Purpose.STACK_POINTER, Occurrence.ONE,
+          Purpose.RETURN_ADDRESS, Occurrence.ONE,
+          Purpose.GLOBAL_POINTER, Occurrence.ONE,
+          Purpose.FRAME_POINTER, Occurrence.ONE,
+          Purpose.THREAD_POINTER, Occurrence.OPTIONAL,
+          Purpose.RETURN_VALUE, Occurrence.ONE,
+          Purpose.CALLER_SAVED, Occurrence.ONE,
+          Purpose.CALLEE_SAVED, Occurrence.ONE,
+          Purpose.FUNCTION_ARGUMENT, Occurrence.ONE);
+    }
   }
 }
 

vadl/main/vadl/ast/MacroExpander.java

@@ -713,7 +713,7 @@ public Definition visit(AbiSequenceDefinition definition) {
   @Override
   public Definition visit(SpecialPurposeRegisterDefinition definition) {
     return new SpecialPurposeRegisterDefinition(
-        definition.purpose, definition.aliasName, copyLoc(definition.loc)
+        definition.purpose, definition.exprs, copyLoc(definition.loc)
     ).withAnnotations(expandAnnotations(definition.annotations));
   }
 

vadl/main/vadl/ast/ParserUtils.java

@@ -685,9 +685,9 @@ static List<SequenceCallExpr> expandSequenceCalls(Parser parser, List<SequenceCa
         } else {
           reportError(parser, "Unknown index type " + callExpr.range, callExpr.range.location());
         }
-        for (; !start.equals(end); start = start.add(BigInteger.valueOf(end.compareTo(start)))) {
+        for (BigInteger i = start; i.compareTo(end) <= 0; i = i.add(BigInteger.ONE)) {
           expandedCalls.add(
-              new SequenceCallExpr(new Identifier(callExpr.target.name + start, callExpr.loc), null,
+              new SequenceCallExpr(new Identifier(callExpr.target.name + i, callExpr.loc), null,
                   callExpr.loc));
         }
       }

vadl/main/vadl/ast/TypeChecker.java

@@ -750,26 +750,42 @@ public Void visit(GroupDefinition groupDefinition) {
   public Void visit(ApplicationBinaryInterfaceDefinition definition) {
     definition.definitions.forEach(this::check);
 
-    // Check whether there exists just one special purpose register.
-    for (var purpose : Set.of(SpecialPurposeRegisterDefinition.Purpose.STACK_POINTER,
-        SpecialPurposeRegisterDefinition.Purpose.RETURN_ADDRESS,
-        SpecialPurposeRegisterDefinition.Purpose.GLOBAL_POINTER,
-        SpecialPurposeRegisterDefinition.Purpose.FRAME_POINTER,
-        SpecialPurposeRegisterDefinition.Purpose.THREAD_POINTER)) {
+    // Check the number of occurrences in the ABI.
+    for (var entry : SpecialPurposeRegisterDefinition.Purpose.numberOfOccurrencesAbi.entrySet()) {
+      var purpose = entry.getKey();
       var registers = definition.definitions.stream().filter(
               x -> x instanceof SpecialPurposeRegisterDefinition specialPurposeRegisterDefinition
                   && specialPurposeRegisterDefinition.purpose == purpose)
           .toList();
 
-      if (registers.size() > 1) {
-        throw Diagnostic.error(
-            "Multiple " + purpose.name() + " registers were declared but only was expected",
-            SourceLocation.join(registers.stream().map(Node::sourceLocation).toList())).build();
-      }
-
-      if (registers.isEmpty()) {
-        throw Diagnostic.error(
-            "No register purpose was defined for " + purpose.name(), definition.loc).build();
+      switch (entry.getValue()) {
+        case ONE -> {
+          if (registers.isEmpty()) {
+            throw Diagnostic.error(
+                "No " + purpose.name() + " registers were declared but one was expected",
+                definition.sourceLocation()).build();
+          } else if (registers.size() != 1) {
+            throw Diagnostic.error(
+                "Multiple " + purpose.name() + " registers were declared but only one was expected",
+                SourceLocation.join(registers.stream().map(Node::sourceLocation).toList())).build();
+          }
+        }
+        case OPTIONAL -> {
+          if (!(registers.isEmpty() || registers.size() == 1)) {
+            throw Diagnostic.error(
+                "Multiple " + purpose.name()
+                    + " registers were declared but zero or one was expected",
+                SourceLocation.join(registers.stream().map(Node::sourceLocation).toList())).build();
+          }
+        }
+        case AT_LEAST_ONE -> {
+          if (registers.isEmpty()) {
+            throw Diagnostic.error(
+                "Zero " + purpose.name() + " registers were declared but at least one was expected",
+                definition.sourceLocation()).build();
+          }
+        }
+        default -> throw new RuntimeException("enum variant not handled");
       }
     }
 
@@ -783,7 +799,7 @@ public Void visit(ApplicationBinaryInterfaceDefinition definition) {
       if (pseudoInstructions.size() > 1) {
         throw Diagnostic.error(
                 "Multiple " + kind.name()
-                    + " pseudo instructions were declared but only was expected",
+                    + " pseudo instructions were declared but only one was expected",
                 SourceLocation.join(pseudoInstructions.stream().map(Node::sourceLocation).toList()))
             .build();
       }
@@ -1382,7 +1398,31 @@ public Void visit(AbiSequenceDefinition definition) {
 
   @Override
   public Void visit(SpecialPurposeRegisterDefinition definition) {
-    // Isn't type checked on purpose because there is nothing to type check.
+    // Check whether the number of registers is correct.
+    // There can be only one stack pointer. However, there might be multiple argument registers.
+    var actual =
+        SpecialPurposeRegisterDefinition.Purpose.numberOfExpectedArguments.get(definition.purpose);
+
+    if (actual == null) {
+      throw Diagnostic.error("Cannot determine number of expected registers",
+          definition.sourceLocation()).build();
+    }
+
+    if (actual == SpecialPurposeRegisterDefinition.Occurrence.ONE) {
+      if (definition.exprs.size() != 1) {
+        throw Diagnostic.error("Number of registers is incorrect. This definition expects only one",
+            definition.sourceLocation()).build();
+      }
+    }
+
+    if (actual == SpecialPurposeRegisterDefinition.Occurrence.ONE) {
+      if (definition.exprs.isEmpty()) {
+        throw Diagnostic.error(
+            "Number of registers is incorrect. This definition expects at least one.",
+            definition.sourceLocation()).build();
+      }
+    }
+
     return null;
   }
 

vadl/main/vadl/ast/ViamLowering.java

@@ -231,6 +231,8 @@ public Optional<vadl.viam.Definition> visit(ApplicationBinaryInterfaceDefinition
     var id = generateIdentifier(definition.viamId, definition.identifier());
     var aliasLookup = aliasLookupTable(definition.definitions);
 
+    // Special Registers
+
     var stackPointerDef = getSpecialPurposeRegisterDefinition(definition.definitions,
         SpecialPurposeRegisterDefinition.Purpose.STACK_POINTER);
     var returnAddressDef =
@@ -240,14 +242,31 @@ public Optional<vadl.viam.Definition> visit(ApplicationBinaryInterfaceDefinition
         SpecialPurposeRegisterDefinition.Purpose.GLOBAL_POINTER);
     var framePtrDef = getSpecialPurposeRegisterDefinition(definition.definitions,
         SpecialPurposeRegisterDefinition.Purpose.FRAME_POINTER);
-    var threadPtrDef = getSpecialPurposeRegisterDefinition(definition.definitions,
-        SpecialPurposeRegisterDefinition.Purpose.THREAD_POINTER);
-
-    var stackPointer = mapToRegisterRef(aliasLookup, stackPointerDef);
-    var returnAddress = mapToRegisterRef(aliasLookup, returnAddressDef);
-    var globalPtr = mapToRegisterRef(aliasLookup, globalPtrDef);
-    var framePtr = mapToRegisterRef(aliasLookup, framePtrDef);
-    var threadPtr = mapToRegisterRef(aliasLookup, threadPtrDef);
+    var threadPtr = getOptionalSpecialPurposeRegisterDefinition(definition.definitions,
+        SpecialPurposeRegisterDefinition.Purpose.THREAD_POINTER)
+        .map(def -> mapSingleSpecialPurposeRegisterDef(aliasLookup, def));
+
+    var stackPointer = mapSingleSpecialPurposeRegisterDef(aliasLookup, stackPointerDef);
+    var returnAddress = mapSingleSpecialPurposeRegisterDef(aliasLookup, returnAddressDef);
+    var globalPtr = mapSingleSpecialPurposeRegisterDef(aliasLookup, globalPtrDef);
+    var framePtr = mapSingleSpecialPurposeRegisterDef(aliasLookup, framePtrDef);
+
+    // Calling Convention
+    var returnValueDef = getSpecialPurposeRegisterDefinition(definition.definitions,
+        SpecialPurposeRegisterDefinition.Purpose.RETURN_VALUE);
+    var functionArgumentDef = getSpecialPurposeRegisterDefinition(definition.definitions,
+        SpecialPurposeRegisterDefinition.Purpose.FUNCTION_ARGUMENT);
+    var callerSavedDef = getSpecialPurposeRegisterDefinition(definition.definitions,
+        SpecialPurposeRegisterDefinition.Purpose.CALLER_SAVED);
+    var calleeSavedDef = getSpecialPurposeRegisterDefinition(definition.definitions,
+        SpecialPurposeRegisterDefinition.Purpose.CALLEE_SAVED);
+
+    var returnValues = mapSpecialPurposeRegistersDef(aliasLookup, returnValueDef);
+    var functionArguments = mapSpecialPurposeRegistersDef(aliasLookup, functionArgumentDef);
+    var callerSaved = mapSpecialPurposeRegistersDef(aliasLookup, callerSavedDef);
+    var calleeSaved = mapSpecialPurposeRegistersDef(aliasLookup, calleeSavedDef);
+
+    // Pseudo Instructions
 
     var pseudoRetInstrDef = getAbiPseudoInstruction(definition.definitions,
         AbiPseudoInstructionDefinition.Kind.RETURN);
@@ -260,6 +279,8 @@ public Optional<vadl.viam.Definition> visit(ApplicationBinaryInterfaceDefinition
     var pseudoCall = (PseudoInstruction) fetch(pseudoCallInstrDef).orElseThrow();
     var pseudoLocalAddressLoad = (PseudoInstruction) fetch(pseudoLocalAddressLoadDef).orElseThrow();
 
+    // Aliases
+
     Map<Pair<RegisterFile, Integer>, List<Abi.RegisterAlias>> aliases =
         aliasLookup.entrySet()
             .stream()
@@ -293,10 +314,10 @@ public Optional<vadl.viam.Definition> visit(ApplicationBinaryInterfaceDefinition
         globalPtr,
         threadPtr,
         aliases,
-        Collections.emptyList(),
-        Collections.emptyList(),
-        Collections.emptyList(),
-        Collections.emptyList(),
+        callerSaved,
+        calleeSaved,
+        functionArguments,
+        returnValues,
         pseudoRet,
         pseudoCall,
         pseudoLocalAddressLoad,
@@ -1257,16 +1278,39 @@ public Optional<vadl.viam.Definition> visit(
     return Optional.ofNullable(pseudoInstructionDefinition).flatMap(this::fetch);
   }
 
+  /**
+   * Maps a {@link SpecialPurposeRegisterDefinition} to a {@link Abi.RegisterRef}.
+   * It expects only one register in the {@link SpecialPurposeRegisterDefinition}. Otherwise,
+   * it will throw an error.
+   */
+  private Abi.RegisterRef mapSingleSpecialPurposeRegisterDef(
+      Map<Identifier, Expr> aliasLookup,
+      SpecialPurposeRegisterDefinition specialPurposeRegisterDef) {
+    var identifier = specialPurposeRegisterDef.exprs.stream().findFirst().orElseThrow().target;
+    return mapToRegisterRef(aliasLookup, identifier);
+  }
+
+  /**
+   * Maps a {@link SpecialPurposeRegisterDefinition} to a list of {@link Abi.RegisterRef}.
+   */
+  private List<Abi.RegisterRef> mapSpecialPurposeRegistersDef(
+      Map<Identifier, Expr> aliasLookup,
+      SpecialPurposeRegisterDefinition specialPurposeRegisterDef) {
+    return specialPurposeRegisterDef.exprs.stream()
+        .map(x -> mapToRegisterRef(aliasLookup, x.target))
+        .toList();
+  }
+
   /**
    * Maps the aliases {@code alias register zero = X(0)} to {@link Abi.RegisterRef} to be
    * used in {@link Abi}.
    */
   private Abi.RegisterRef mapToRegisterRef(
       Map<Identifier, Expr> aliasLookup,
-      SpecialPurposeRegisterDefinition specialPurposeRegisterDef) {
-    var expr = ensureNonNull(aliasLookup.get(specialPurposeRegisterDef.aliasName),
+      Identifier identifier) {
+    var expr = ensureNonNull(aliasLookup.get(identifier),
         () -> Diagnostic.error("Cannot alias for register definition",
-            specialPurposeRegisterDef.aliasName.sourceLocation()));
+            identifier.sourceLocation()));
     var pair = getRegisterFile(expr);
     var registerFile = pair.left();
     var index = pair.right();
@@ -1319,12 +1363,21 @@ private Map<Identifier, Expr> aliasLookupTable(List<Definition> definitions) {
    */
   private SpecialPurposeRegisterDefinition getSpecialPurposeRegisterDefinition(
       List<Definition> definitions, SpecialPurposeRegisterDefinition.Purpose purpose) {
+    return getOptionalSpecialPurposeRegisterDefinition(definitions, purpose).get();
+  }
+
+  /**
+   * Extracts a {@link SpecialPurposeRegisterDefinition} with the given {@code purpose}.
+   * It is ok to find no definition.
+   */
+  private Optional<SpecialPurposeRegisterDefinition> getOptionalSpecialPurposeRegisterDefinition(
+      List<Definition> definitions, SpecialPurposeRegisterDefinition.Purpose purpose) {
     var registers = definitions
         .stream()
         .filter(x -> x instanceof SpecialPurposeRegisterDefinition y && y.purpose == purpose)
         .toList();
 
-    return (SpecialPurposeRegisterDefinition) registers.stream().findFirst().get();
+    return registers.stream().findFirst().map(x -> (SpecialPurposeRegisterDefinition) x);
   }