From 7cf539cf05eb7ed2d150f01a899a05471eb8f502 Mon Sep 17 00:00:00 2001
From: jalcim <alcim.dev@gmail.com>
Date: Wed, 4 Mar 2026 11:46:07 +0000
Subject: [PATCH] Add --func-recursion-depth CLI option (#7175) (#7179)

---
 bin/verilator                          |  1 +
 docs/guide/exe_verilator.rst           |  8 ++++++++
 src/V3Options.cpp                      |  1 +
 src/V3Options.h                        |  2 ++
 src/V3Simulate.h                       |  6 +++---
 test_regress/t/t_func_recurse_depth.py | 18 ++++++++++++++++++
 test_regress/t/t_func_recurse_depth.v  | 24 ++++++++++++++++++++++++
 7 files changed, 57 insertions(+), 3 deletions(-)
 create mode 100755 test_regress/t/t_func_recurse_depth.py
 create mode 100644 test_regress/t/t_func_recurse_depth.v

diff --git a/bin/verilator b/bin/verilator
index ab07e6201..03ae90424 100755
--- a/bin/verilator
+++ b/bin/verilator
@@ -390,6 +390,7 @@ detailed descriptions of these arguments.
      -f <file>                  Parse arguments from a file
      -FI <file>                 Force include of a file
     --flatten                   Force inlining of all modules, tasks and functions
+    --func-recursion-depth <value>  Maximum recursive constant function depth
     --future0 <option>          Ignore an option for compatibility
     --future1 <option>          Ignore an option with argument for compatibility
      -fno-<optimization>        Disable internal optimization stage
diff --git a/docs/guide/exe_verilator.rst b/docs/guide/exe_verilator.rst
index 791d9417f..fd687f6f6 100644
--- a/docs/guide/exe_verilator.rst
+++ b/docs/guide/exe_verilator.rst
@@ -733,6 +733,14 @@ Summary:
    Rarely needed. Set the maximum array size (number of elements) for slice
    optimization to avoid excessive memory usage.
 
+.. option:: --func-recursion-depth <value>
+
+   Specifies the maximum depth of recursive constant function evaluation.
+   When a recursive function exceeds this depth during constant folding,
+   Verilator gives up and treats the expression as non-constant.
+
+   Defaults to 1000.
+
 .. option:: -future0 <option>
 
    Rarely needed. Suppress an unknown Verilator option for an option that
diff --git a/src/V3Options.cpp b/src/V3Options.cpp
index 7018bc296..3d6b15bb3 100644
--- a/src/V3Options.cpp
+++ b/src/V3Options.cpp
@@ -1590,6 +1590,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc,
             fl->v3error("Unknown --make system specified: '" << valp << "'");
         }
     });
+    DECL_OPTION("-func-recursion-depth", Set, &m_funcRecursion);
     DECL_OPTION("-max-num-width", Set, &m_maxNumWidth);
     DECL_OPTION("-mod-prefix", CbVal, [this, fl](const char* valp) {
         validateIdentifier(fl, valp, "--mod-prefix");
diff --git a/src/V3Options.h b/src/V3Options.h
index 138c597b3..59a636cfe 100644
--- a/src/V3Options.h
+++ b/src/V3Options.h
@@ -330,6 +330,7 @@ private:
     int         m_localizeMaxSize = 1024;  // main switch: --localize-max-size
     VOptionBool m_makeDepend;  // main switch: -MMD
     int         m_maxNumWidth = 65536;  // main switch: --max-num-width
+    int         m_funcRecursion = 1000;  // main switch: --func-recursion-depth
     int         m_moduleRecursion = 100;  // main switch: --module-recursion-depth
     int         m_outputGroups = -1;  // main switch: --output-groups
     int         m_outputSplit = 20000;  // main switch: --output-split
@@ -612,6 +613,7 @@ public:
     bool jsonIds() const { return m_jsonIds; }
     VOptionBool makeDepend() const { return m_makeDepend; }
     int maxNumWidth() const { return m_maxNumWidth; }
+    int funcRecursionDepth() const { return m_funcRecursion; }
     int moduleRecursionDepth() const { return m_moduleRecursion; }
     int outputSplit() const { return m_outputSplit; }
     int outputSplitCFuncs() const { return m_outputSplitCFuncs; }
diff --git a/src/V3Simulate.h b/src/V3Simulate.h
index 7b16dec7f..d945ba8da 100644
--- a/src/V3Simulate.h
+++ b/src/V3Simulate.h
@@ -75,7 +75,6 @@ class SimulateVisitor VL_NOT_FINAL : public VNVisitorConst {
 
 private:
     // CONSTANTS
-    static constexpr int CONST_FUNC_RECURSION_MAX = 1000;
     static constexpr int CALL_STACK_MAX = 100;
 
     // NODE STATE
@@ -1158,9 +1157,10 @@ private:
         UASSERT_OBJ(funcp, nodep, "Not linked");
 
         if (funcp->recursive()) {
-            if (m_recurseCount >= CONST_FUNC_RECURSION_MAX) {
+            if (m_recurseCount >= v3Global.opt.funcRecursionDepth()) {
                 clearOptimizable(funcp, "Constant function recursed more than "s
-                                            + std::to_string(CONST_FUNC_RECURSION_MAX) + " times");
+                                            + std::to_string(v3Global.opt.funcRecursionDepth())
+                                            + " times");
                 return;
             }
             ++m_recurseCount;
diff --git a/test_regress/t/t_func_recurse_depth.py b/test_regress/t/t_func_recurse_depth.py
new file mode 100755
index 000000000..4c62c5249
--- /dev/null
+++ b/test_regress/t/t_func_recurse_depth.py
@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of either the GNU Lesser General Public License Version 3
+# or the Perl Artistic License Version 2.0.
+# SPDX-FileCopyrightText: 2026 by Wilson Snyder
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+import vltest_bootstrap
+
+test.scenarios('simulator')
+
+test.compile(verilator_flags2=['--func-recursion-depth 2000'])
+
+test.execute()
+
+test.passes()
diff --git a/test_regress/t/t_func_recurse_depth.v b/test_regress/t/t_func_recurse_depth.v
new file mode 100644
index 000000000..b1912af8f
--- /dev/null
+++ b/test_regress/t/t_func_recurse_depth.v
@@ -0,0 +1,24 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed under the Creative Commons Public Domain.
+// SPDX-FileCopyrightText: 2026 jalcim
+// SPDX-License-Identifier: CC0-1.0
+
+module t;
+
+  // Recursive function that needs depth > 1000 to constant-fold
+  function automatic int recurse_sum;
+    input int i;
+    if (i == 0) recurse_sum = 0;
+    else recurse_sum = i + recurse_sum(i - 1);
+  endfunction
+
+  localparam int S1500 = recurse_sum(1500);
+
+  initial begin
+    if (S1500 !== 1125750) $stop;
+    $write("*-* All Finished *-*\n");
+    $finish;
+  end
+
+endmodule