Java递归函数getFunctionReferences时而可用时而栈溢出求助

Hey there! It sounds like your recursive getFunctionReferences function is hitting stack overflow issues—super common when dealing with recursive traversal of block structures, especially when there are cycles or deep chains. Let’s break down why this happens and how to fix it.

Common Causes of the Stack Overflow #

• Circular References: If your BasicBlocks form a cycle (e.g., Block A references Block B, and Block B references Block A), your recursion will loop infinitely until the system stack runs out of space.
• Excessive Recursion Depth: Even without cycles, if your function has to traverse hundreds or thousands of nested blocks, the default system stack size might not be enough to handle that many recursive calls.

Solutions to Fix the Issue #

1. Replace Recursion with Iteration (Most Reliable) #

Instead of relying on the system call stack, manually manage your traversal with a stack or queue data structure. This avoids stack overflow entirely, regardless of how deep or cyclic your block structure is.

Here’s an example implementation (adjust based on your actual code structure):

def getFunctionReferences(start_block):
    visited_addresses = set()
    all_references = []
    # Use a stack to keep track of blocks we need to process
    block_stack = [start_block]

    while block_stack:
        current_block = block_stack.pop()
        # Iterate through all addresses referenced by the current block
        for addr in current_block.addresses:
            if addr not in visited_addresses:
                visited_addresses.add(addr)
                all_references.append(addr)
                # Fetch the BasicBlock corresponding to this address (adjust this part to your code)
                referenced_block = get_block_from_address(addr)
                block_stack.append(referenced_block)
    
    return all_references

2. Add a Visited Set to Your Recursive Function #

If you prefer keeping the recursive approach, add a set to track addresses you’ve already processed. This stops the recursion from looping indefinitely on cycles and avoids redundant work.

Example recursive implementation:

def getFunctionReferences(current_block, visited_addresses=None):
    # Initialize the visited set on the first call
    if visited_addresses is None:
        visited_addresses = set()
    
    references = []
    for addr in current_block.addresses:
        if addr not in visited_addresses:
            visited_addresses.add(addr)
            references.append(addr)
            # Fetch the referenced block and recurse
            referenced_block = get_block_from_address(addr)
            references.extend(getFunctionReferences(referenced_block, visited_addresses))
    
    return references

3. (Not Recommended) Increase Recursion Limit #

Some languages let you adjust the maximum recursion depth (like Python’s sys.setrecursionlimit()), but this is a band-aid. It doesn’t fix the root cause of cycles, and you might still hit limits or crash if the structure is too deep. Only use this if you’re certain there are no cycles and just need a temporary fix.

Why These Work #

• The iterative approach uses a heap-allocated stack instead of the system’s call stack, which has much more space.
• The visited set ensures we never process the same address twice, eliminating infinite loops from cycles and reducing unnecessary recursive calls.

内容的提问来源于stack exchange，提问作者user7183233