How do we know that last_die is valid here? Suppose addr2line is given two addresses as input. The first address is valid, and results in last_die being set. The second address is invalid (i.e., doesn't match any CU). When we process the first address, we will cache the DIE for its CU. When processing the second address, we will free last_die and set it to NULL, but locache and hicache are still left with their old values. So, when processing a third address, we may goto status_ok even though last_die is NULL.

As I understand it, this means that on a cache miss, we will resume the CU scan from the last place where we found a match. Is there any specific reason to do it that way? Why not always restart the search from the beginning on a cache miss.

Why not replace all instances of "goto not_found" with "goto out"?

I think it would be clearer if cache invalidation and cache insertion were done in the same place. That is, it is kind of confusing that last_die is freed above. Instead, you could keep last_die valid in the cache until a new match is found, instead of invalidating as soon as there is a cache miss. I think this should result in fewer gotos and make the control flow easier to follow.

The indentation here is still wrong.

I still can't see the reason for this.

Can you explain this check? I don't quite see why it's there.

Is it possible to have die != last_die here?

Because when we have 2 sequential addresses, and the second one is of the next CU, it is faster to just go to the next CU instead of starting from the beginning.

From My understanding:
CU1: ffff0000-ffff0100
...
CU10: ffff1000 - ffff1100
CU11: ffff1100 - ffff1200
We give the program:
ffff1098
ffff1105
If we scan from the last place we found a match (CU10), we call dwarf_next_cu_header once.
If we scan from the beginning, we call dwarf_next_cu_header 11 times and go through the loop 11 times.
Not sure if I'm correct though.

This is if we scanned across all the CU's and get back to where we started, we want to go to out because we cannot translate this address.

I guess DIE always equals last_die

Shouldn't it be last_die != NULL?

Got it. You might consider adding a short comment above the goto next_cu to explain this.

I see. But if the cache is invalid, this check will fail.

Only need this check**

Only need this check on a cache miss.

Sorry, I was not specific enough. If the cache is invalid *and* the address is invalid, we will never exit the loop.

I think we can remove the "else if" case since we changed next_cu to not invalidate cache until cache insertion. Next_cu now frees die if die is not NULL but die is always NULL in the "else if" case.