递归调用时链表无法保留值？汇编Call/Return地址存储异常

Hey there, let's dig into why your Return instruction is losing the stored address from the linked list. Based on what you've described, here are the most likely culprits and actionable fixes to try:

Common Issues & Fixes #

1. Linked List Node Lifecycle Mistake #

If you're creating linked list nodes using stack memory (local variables inside your recursive parsing function) when handling Call instructions, those nodes get destroyed once the recursive call exits. When you hit Return later, the memory where the address was stored is already overwritten or invalid.

Fix: Always allocate nodes on the heap using malloc (C) or new (C++) so their memory persists across recursive calls. For example:

// When handling Call instruction
Node* new_node = (Node*)malloc(sizeof(Node));
new_node->addr = current_return_address;
new_node->next = head;
head = new_node; // Add to the front (stack-like LIFO behavior)

2. Incorrect Pointer Handling for Return #

It’s easy to accidentally overwrite or lose access to the stored address when popping from the linked list. If you’re releasing the node before reading its value, or mismanaging the head pointer, the data will seem "lost".

Fix: Follow this order for Return handling:

if (strcmp(instruction, "RETURN") == 0) {
    if (head == NULL) {
        // Handle error: Return without matching Call
        return;
    }
    // 1. First save the return address before modifying the list
    void* target_addr = head->addr;
    // 2. Save the current head to free it later
    Node* temp = head;
    // 3. Update the head to point to the next node
    head = head->next;
    // 4. Clean up the popped node (if heap-allocated)
    free(temp);
    // 5. Use the saved address for your logic
    jump_to_address(target_addr);
}

3. Passing the Linked List Head by Value #

If your recursive parsing function takes the linked list head as a regular pointer (not a pointer-to-pointer), any changes you make to the head (like adding/removing nodes) won’t propagate back to the parent recursive calls. The parent will still see the old head state, making it look like data was lost.

Fix: Pass a pointer to the head pointer in your function signature:

// Correct signature: allows modifying the original head
void parse_assembly_line(char* line, Node** head) {
    // When adding a node:
    (*head) = new_node;
}

// Call it like this from your main/parent function
parse_assembly_line(next_line, &head);

4. Wrong Linked List Behavior (Not LIFO) #

Call/Return follows a Last-In-First-Out (LIFO) stack pattern. If you’re adding Call addresses to the end of the linked list but trying to pop from the front (or vice versa), you’ll be retrieving the wrong address, which can look like data loss.

Fix: Treat the linked list as a stack:

• When handling Call: Insert new nodes at the front of the list
• When handling Return: Remove nodes from the front of the list

Debugging Tip #

Add print statements to log the linked list state every time you process a Call or Return. For example:

// After adding a Call node
printf("Call added: addr = %p, head now points to %p\n", new_node->addr, head);

// Before processing Return
printf("Return hit: current head addr = %p, stored value = %p\n", head, head->addr);

This will help you confirm if the address is actually being stored correctly, and whether it’s accessible when Return is processed.

Hope these pointers help you track down the issue. Let me know if you want to share code snippets for more targeted troubleshooting!

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