fixed struct args in wrapped subaction functions.

Author: cemcebeci

lib/dialect/include/rlc/dialect/DynamicArgumentAnalysis.hpp

@@ -78,10 +78,10 @@ struct UnboundValue {
     llvm::SmallVector<uint64_t> memberAddress;
 
     /*
-        Returns whether this unbound value corressponds to the term.
+        Returns whether this unbound value corressponds to the expression.
     */
-    bool matches(mlir::Value term) {
-        mlir::Value current = term;
+    bool matches(mlir::Value expr) {
+        mlir::Value current = expr;
         // walk the member address in reverse, test if it leads to the argument.
         for(uint64_t & index : std::ranges::reverse_view(memberAddress)) {
             auto definingOp = current.getDefiningOp();
@@ -99,6 +99,32 @@ struct UnboundValue {
         return current == argument;
     }
 
+    /*
+        Returns true if this unbound value is a recursive member of the given expression.
+    */
+    bool isMemberOf(mlir::Value expr) {
+        mlir::Value current = expr;
+        llvm::SmallVector<uint64_t> indices;
+
+        while(true) {
+            if(current == argument) {
+                for(size_t i = 0; i < indices.size();  i++) {
+                    if(indices[i] != memberAddress[i])
+                        return false;
+                }
+                return true;
+            }
+
+            auto definingOp = current.getDefiningOp();
+            if( not llvm::detail::isPresent(definingOp))
+                return false;
+            if(auto memberAccess = mlir::dyn_cast<mlir::rlc::MemberAccess>(definingOp)) {
+                indices.insert(indices.begin(), memberAccess.getMemberIndex());
+                current = memberAccess.getValue();
+            } else return false;
+        }
+    }
+
     mlir::Type getType() {
         auto type = argument.getType();
         for (auto index : memberAddress) {

lib/dialect/src/DynamicArgumentAnalysisPass.cpp

@@ -86,7 +86,7 @@ llvm::SmallVector<llvm::SmallVector<mlir::Value>> DynamicArgumentAnalysis::expan
 }
 
 TermType DynamicArgumentAnalysis::decideTermType(mlir::Value term, UnboundValue unbound) {
-    if(unbound.matches(term))
+    if(unbound.isMemberOf(term))
         return DEPENDS_ON_UNBOUND;
 
     auto boundValue = getBoundValue(term);
@@ -265,14 +265,14 @@ DeducedConstraints DynamicArgumentAnalysis::findImposedConstraints(mlir::rlc::Ca
                 continue;
             }
             // and find the index of the argument we're interested in.
-            if(unbound.matches(current.value())) {
+            if(unbound.argument == current.value()) {
                 argIndex = current.index();
                 break;
             }
         }
         assert(argIndex != -1 && "Expected to find the argument.");
         DynamicArgumentAnalysis analysis(underlyingFunction, knownArgsOfUnderlyingFunction, argPicker, builder, loc);
-        UnboundValue correspongindUnboundValue {underlyingFunction.getPrecondition().getArgument(argIndex), {}};
+        UnboundValue correspongindUnboundValue {underlyingFunction.getPrecondition().getArgument(argIndex), unbound.memberAddress};
         return analysis.deduceIntegerUnboundValueConstraints(correspongindUnboundValue);
     }
     return {
@@ -399,13 +399,6 @@ DeducedConstraints DynamicArgumentAnalysis::deduceIntegerUnboundValueConstraints
             }
         }
 
-        llvm::dbgs() << "CONSTRAINTS: \n";
-        for (auto t : constraints) {
-                llvm::dbgs() << "(  ";
-                t.print(llvm::dbgs());
-                llvm::dbgs() << "   ),";
-            }
-            llvm::dbgs() << "\n";
 
         // if there are any constraints on unknown args, emit an if statement for this conjunction.
         if(constraints.size() > 0) {

tool/rlc/test/fuzzer_pick_struct.rl

@@ -1,15 +1,34 @@
 import fuzzer.cpp_functions
 import fuzzer.utils
 
+fun crash() {false}:
+    return
+
 ent Test:
     Int a
     Int b
 
+act subact(ctx Test context_struct) -> Subact:
+    frm subact_frame_var : Int
+    subact_frame_var = 250
+    act uses_context_struct(Test t1) {
+        t1.a == context_struct.b,
+        t1.b > context_struct.a,
+        t1.b < subact_frame_var
+    }
+
 act play() -> Play:
+    frm struct_in_frame : Test
     act uses_struct(Test t) {
         t.a >= 0,
         t.a <= 5,
         t.b >= -10,
         t.a <= 2 or t.b >= 5,
         t.b <= 16
     }
+    struct_in_frame = t
+
+    subaction*(struct_in_frame) s = subact(struct_in_frame) 
+    crash()
+
+