lcb: Relocation modifiers (#500)

* spec: Add relocation `syntax` to risc-v

* ast: Added new annotation

* spec: Dropped backslash because it is not supported

* chore: Updated tests because obsolete relocattions were deleted

* ast: Pass on the annotation's string value

* lcb: Implemented the printing of relocation via annotation

* lcb: Add pseudo instruction for loading addresses

* lcb: Generated case where we print arbitrary expressions for field
access functions

* lcb: Working on pseudo inst expansion for address loading

* lcb: Fixed CheckStyle

* lcb: Updated test

* lcb: Fixed test

Author: kper

vadl/main/resources/templates/lcb/llvm/lib/Target/MCTargetDesc/AsmUtils.cpp

@@ -222,6 +222,18 @@ std::string AsmUtils::formatExpr(const MCExpr *Expr, uint8_t Radix, const MCAsmI
     llvm_unreachable("Invalid expression kind!");
 }
 
+
+std::string AsmUtils::FormatModifierString(const [(${namespace})]MCExpr::VariantKind VariantKind)
+{
+    [# th:each="fm : ${formatModifiers}" ]
+    if(VariantKind == [(${namespace})]MCExpr::VariantKind::[(${fm.variantKind})]) {
+      return "[(${fm.formatString})]";
+    }
+    [/]
+
+    return "unknown";
+}
+
 std::string AsmUtils::FormatModifier(const [(${namespace})]MCExpr::VariantKind VariantKind)
 {
     [# th:each="fm : ${formatModifiers}" ]

vadl/main/resources/templates/lcb/llvm/lib/Target/MCTargetDesc/AsmUtils.h

@@ -26,6 +26,7 @@ namespace llvm
             static std::string formatImm(MCOperand Op, uint8_t Radix, const MCAsmInfo *MAI);
             static std::string formatImm(int64_t value, uint8_t Radix, const MCAsmInfo *MAI);
             static std::string formatExpr(const MCExpr *Expr, uint8_t Radix, const MCAsmInfo *MAI);
+            static std::string FormatModifierString(const [(${namespace})]MCExpr::VariantKind VariantKind);
             static std::string FormatModifier(const [(${namespace})]MCExpr::VariantKind VariantKind);
             static std::string FormatModifier(const MCSymbolRefExpr::VariantKind VariantKind);
             static bool MatchRegNo(StringRef Reg, unsigned &RegNo);

vadl/main/resources/templates/lcb/llvm/lib/Target/MCTargetDesc/TargetMCExpr.cpp

@@ -9,6 +9,10 @@
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/ErrorHandling.h"
+#include <sstream>
+#include <iostream>
+#include <format>
+#include <vector>
 
 using namespace llvm;
 
@@ -28,6 +32,33 @@ void [(${namespace})]MCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) co
     OS << format(10, MAI);
 }
 
+template<typename T>
+std::string to_string_any(const T& value) {
+    std::ostringstream oss;
+    oss << value;
+    return oss.str();
+}
+
+// Remove when llvm supports C++ 20.
+template<typename... Args>
+std::string custom_format(const std::string& fmt, Args&&... args) {
+    // Convert all arguments to strings
+    std::vector<std::string> values{ to_string_any(std::forward<Args>(args))... };
+
+    std::string result;
+    size_t argIndex = 0;
+
+    for (size_t i = 0; i < fmt.size(); ++i) {
+        if (fmt[i] == '{' && i + 1 < fmt.size() && fmt[i + 1] == '}' && argIndex < values.size()) {
+            result += values[argIndex++];
+            ++i; // skip the '}'
+        } else {
+            result += fmt[i];
+        }
+    }
+    return result;
+}
+
 std::string [(${namespace})]MCExpr::format(uint8_t Radix, const MCAsmInfo *MAI) const
 {
     bool HasVariant = (Kind != VK_None);
@@ -60,12 +91,9 @@ std::string [(${namespace})]MCExpr::format(uint8_t Radix, const MCAsmInfo *MAI)
         return subexpr + suffix;
     }
 
-    std::string result = "";
-    result += "%";
-    result += AsmUtils::FormatModifier(getKind());
-    result += "(";
-    result += subexpr;
-    result += ')';
+    std::string fmt = AsmUtils::FormatModifierString(getKind());
+    std::string mod = AsmUtils::FormatModifier(getKind());
+    std::string result = custom_format(fmt, mod, subexpr);
     return result;
 }
 

vadl/main/vadl/ast/AnnotationTable.java

@@ -38,6 +38,7 @@
 import javax.annotation.Nullable;
 import vadl.error.Diagnostic;
 import vadl.gcb.annotations.OnlyNegativeNumbersAnnotation;
+import vadl.gcb.annotations.RelocationSyntaxAnnotation;
 import vadl.gcb.annotations.SkipPruningAnnotation;
 import vadl.gcb.annotations.StatusRegisterAnnotation;
 import vadl.types.Type;
@@ -255,6 +256,11 @@ public class AnnotationTable {
           def.addAnnotation(new DefineOperandAnnotation(fields));
         }).build();
 
+    annotationOn(RelocationDefinition.class, "syntax", StringAnnotation::new)
+        .applyViam((def, annotation, lowering) -> {
+          var lit = (StringLiteral) annotation.definition.values.getFirst();
+          def.addAnnotation(new RelocationSyntaxAnnotation(lit.value));
+        }).build();
   }
 
   /**

vadl/main/vadl/cppCodeGen/common/ValueRelocationFunctionCodeGenerator.java

@@ -18,6 +18,7 @@
 
 import static vadl.utils.GraphUtils.getSingleNode;
 
+import java.util.Optional;
 import vadl.cppCodeGen.AbstractRelocationCodeGenerator;
 import vadl.cppCodeGen.CppTypeMap;
 import vadl.cppCodeGen.context.CGenContext;
@@ -48,7 +49,7 @@ public class ValueRelocationFunctionCodeGenerator extends AbstractRelocationCode
    * Options for the function which is generated by the code
    * generator.
    */
-  public record Options(boolean isConst, boolean isStatic) {
+  public record Options(boolean isConst, boolean isStatic, Optional<String> classPrefix) {
 
   }
 
@@ -62,7 +63,7 @@ public ValueRelocationFunctionCodeGenerator(
     this.relocation = relocation;
     this.functionName =
         relocation.identifier.lower();
-    this.options = new Options(false, false);
+    this.options = new Options(false, false, Optional.empty());
     this.context = new CNodeContext(
         builder::append,
         (ctx, node)

vadl/main/vadl/gcb/annotations/RelocationSyntaxAnnotation.java

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText : © 2025 TU Wien <vadl@tuwien.ac.at>
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package vadl.gcb.annotations;
+
+import vadl.viam.Annotation;
+import vadl.viam.Relocation;
+
+/**
+ * Defines how the compiler generator will print the relocation in the assembly.
+ */
+public class RelocationSyntaxAnnotation extends Annotation<Relocation> {
+  private final String formatString;
+
+  public RelocationSyntaxAnnotation(String formatString) {
+    this.formatString = formatString;
+  }
+
+  @Override
+  public Class<Relocation> parentDefinitionClass() {
+    return Relocation.class;
+  }
+
+  public String formatString() {
+    return formatString;
+  }
+}