Change the looping stack detection code

[tberghammer]

Summary

Change the looping stack detection code

In some special case (e.g. signal handlers, hand written assembly) it is
valid to have 2 stack frame with the same CFA value. This CL change the
looping stack detection code to report a loop only if at least 3
consecutive frames have the same CFA.

Note: I would prefer to get rid of this looping stack detection because the implementation is still a bit flaky and rely on the logic in UnwindLLDB::GetOneMoreFrame to stop the infinite loop in case of a looping stack, but I don't know how big the user impact will be in the cases where the unwind go wrong and start looping

[jasonmolenda]

I'm fine with this change. On x86, where the CALL instruction pushes the return address on the stack, you can't have two stack frames with the CFA. If we have a loop, I don't think it's a big problem if we only break out once it's a 3-stack-frame loop.

I'm not sure it's possible to have an arbitrary number of stack frames with the same CFA - the return addresses have to be saved somewhere. The register file only gives us so many volatile registers we can use to save multiple stack frame's return addresses before we need to write something to the stack.

[tberghammer]

In ABI conforming code we will never have even 2 consecutive frames with the same CFA for all ABI I know about.
In practice, 2 consecutive frame with the same CFA can happen (for hand written assembly and signal handling), but more then 2 is highly unlikely.
In theory, arbitrary number of frames can have the same CFA if the code sets up a different stack for itself (in a different location) what we don't track, but it is just a hypothetical case.

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

RegisterContextLLDB::InitializeNonZerothFrame()
     UnwindLogMsg ("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64,
             (uint64_t) m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr()), (uint64_t) m_cfa);
 }
 
 bool
 RegisterContextLLDB::CheckIfLoopingStack ()
 {
     // If we have a bad stack setup, we can get the same CFA value multiple times -- or even
-    // more devious, we can actually oscillate between two CFA values.  Detect that here and
+    // more devious, we can actually oscillate between two CFA values. Detect that here and
     // break out to avoid a possible infinite loop in lldb trying to unwind the stack.
-    addr_t next_frame_cfa;
+    // To detect when we have the same CFA value multiple times, we compare the CFA of the current
+    // frame with the 2nd next frame because in some specail case (e.g. signal hanlders, hand
+    // written assembly without ABI compiance) we can have 2 frames with the same CFA (in theory we
+    // can have arbitrary number of frames with the same CFA, but more then 2 is very very unlikely)
+
+    RegisterContextLLDB::SharedPtr next_frame = GetNextFrame();
+    if (next_frame)
+    {
+        RegisterContextLLDB::SharedPtr next_next_frame = next_frame->GetNextFrame();
         addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS;
-    if (GetNextFrame().get() && GetNextFrame()->GetCFA(next_frame_cfa))
+        if (next_next_frame && next_next_frame->GetCFA(next_next_frame_cfa))
         {
-        if (next_frame_cfa == m_cfa)
+            if (next_next_frame_cfa == m_cfa)
             {
                 // We have a loop in the stack unwind
-            return true;
+                return true; 
             }
-        if (GetNextFrame()->GetNextFrame().get() && GetNextFrame()->GetNextFrame()->GetCFA(next_next_frame_cfa)
-            && next_next_frame_cfa == m_cfa)
-        {
-            // We have a loop in the stack unwind
-            return true; 
         }
     }
     return false;
 }
 
-
 bool
 RegisterContextLLDB::IsFrameZero () const
 {
     return m_frame_number == 0;
 }
 
 
 // Find a fast unwind plan for this frame, if possible.