Fix to solve Bug 23139 & Bug 23560

[abhishek.aggarwal]

Summary

• Reason of both bugs:
  1. For the very first frame, Unwinder doesn't check the validity of Full UnwindPlan before creating StackFrame from it:
     
     When 'process launch' command is run after setting a breakpoint in inferior, the Unwinder runs and saves only Frame 0 (the frame in which breakpoint was set) in thread's StackFrameList i.e. m_curr_frames_sp. However, it doesn't check the validity of the Full UnwindPlan for this frame by unwinding 2 more frames further.
  2. Unwinder doesn't update the CFA value of Cursor when Full UnwindPlan fails and FallBack UnwindPlan succeeds in providing valid CFA values for frames:
     
     Sometimes during unwinding of stack frames, the Full UnwindPlan inside the RegisterContextLLDB object may fail to provide valid CFA values for these frames. Then the Fallback UnwindPlan is used to unwind the frames.
     
     If the Fallback UnwindPlan succeeds, then it provides a valid new CFA value. The RegisterContextLLDB::m_cfa field of Cursor object is updated during the Fallback UnwindPlan execution. However, UnwindLLDB misses the implementation to update the 'cfa' field of this Cursor with this valid new CFA value.
• This patch fixes both these issues.
• Remove XFAIL in test files corresponding to these 2 Bugs

Change-Id: I932ea407545ceee2d628f946ecc61a4806d4cc86
Signed-off-by: Abhishek Aggarwal <[e-mail]>

[clayborg]

I will defer to Jason Molenda.

[jasonmolenda]

Hi Abhishek, I apologize for the long delay in reviewing this one, I needed to find a solid 30-45 minute block to review the changes and the current state of the unwinder code before I really understood what is going on here.

I think this change looks good, please commit it when you have a chance.

source/Plugins/Process/Utility/UnwindLLDB.cpp

320 ↗

(On Diff #38893)

I would do this with an assert instead of a conditional check. This method is only called from UnwindLLDB::AddFirstFrame(). AddFirstFrame starts by ensuring that m_frames is empty. It constructs a Cursor object for the first stack frame, pushes it to m_frames. And then it calls UpdateUnwindPlanForFirstFrameIfInvalid().

A conditional makes it look like this is a possible valid arrangement. Instead, what we're checking here is a basic assumption of the state of the object when this method should be called. I think it's an appropriate space to use an assert. If the code were to ever change around this method (or this method was called from another part of the code), we'd need it to crash immediately because the code would no longer be correct.

[abhishek.aggarwal]

Used Assert instead of If condition

[abhishek.aggarwal]

Removed log and inserted statement terminator

[abhishek.aggarwal]

Hello Jason

No problem regarding the delay. Thanks a lot for reviewing the patch. I have made the changes as suggested by you. I will land it now.

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/TestMultithreaded.py

 
 class SBBreakpointCallbackCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @skipIfNoSBHeaders
     @skipIfWindows # clang-cl does not support throw or catch (llvm.org/pr24538)
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["x86_64"])
     def test_breakpoint_callback(self):
         """Test the that SBBreakpoint callback is invoked when a breakpoint is hit. """
         self.build_and_test('driver.cpp test_breakpoint_callback.cpp',
                             'test_breakpoint_callback')
 
     @skipIfRemote
     @skipIfNoSBHeaders
     @skipIfWindows # clang-cl does not support throw or catch (llvm.org/pr24538)
     @expectedFlakeyFreeBSD
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["x86_64"])
     def test_sb_api_listener_event_description(self):
         """ Test the description of an SBListener breakpoint event is valid."""
         self.build_and_test('driver.cpp listener_test.cpp test_listener_event_description.cpp',
                             'test_listener_event_description')
         pass
 
     @skipIfRemote
     @skipIfNoSBHeaders
     @skipIfWindows # clang-cl does not support throw or catch (llvm.org/pr24538)
     @expectedFlakeyFreeBSD
     @expectedFlakeyLinux # Driver occasionally returns '1' as exit status
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["x86_64"])
     def test_sb_api_listener_event_process_state(self):
         """ Test that a registered SBListener receives events when a process
             changes state.
         """
         self.build_and_test('driver.cpp listener_test.cpp test_listener_event_process_state.cpp',
                             'test_listener_event_process_state')
         pass
 

lldb/trunk/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py

class BasicExprCommandsTestCase(TestBase):
     @unittest2.expectedFailure("llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.")
     def test_floating_point_expr_commands(self):
         self.build_and_run()
 
         self.expect("expression 2.234f",
             patterns = ["\(float\) \$.* = 2\.234"])
         # (float) $2 = 2.234
 
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows("llvm.org/pr21765")
     def test_many_expr_commands(self):
         self.build_and_run()
 
         self.expect("expression 2",
             patterns = ["\(int\) \$.* = 2"])
         # (int) $0 = 1
 
def test_many_expr_commands(self):
         # (const char *) $7 = ...
 
         self.expect("expression argv[0]",
             substrs = ["(const char *)", 
                        "a.out"])
         # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
 
     @add_test_categories(['pyapi'])
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows # Test crashes
     def test_evaluate_expression_python(self):
         """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
         self.build()
 
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synth/TestDataFormatterSynth.py

class SynthDataFormatterTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["x86_64","i386"])
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py

class ConvenienceVariablesCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.c', 'Hello world.')
 
     @skipIfFreeBSD # llvm.org/pr17228
     @skipIfRemote
-    @expectedFailureAll("llvm.org/pr23560", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_with_run_commands(self):
         """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
         self.build()
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
         python_prompt = ">>> "

lldb/trunk/packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py

def test_inferior_crashing_python(self):
         self.inferior_crashing_python()
 
     @expectedFailureWindows("llvm.org/pr24778")
     def test_inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
         self.build()
         self.inferior_crashing_expr()
 
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows("llvm.org/pr24778")
     def test_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.inferior_crashing_step()
 
     @expectedFailureFreeBSD('llvm.org/pr24939')
     @expectedFailureWindows("llvm.org/pr24778")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py

 
 class TestInlineStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     @expectedFailureFreeBSD('llvm.org/pr17214')
     @expectedFailureIcc # Not really a bug.  ICC combines two inlined functions.
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows("llvm.org/pr24778")
     # failed 1/365 dosep runs, (i386-clang), TestInlineStepping.py:237 failed to stop at first breakpoint in main
     @expectedFailureAll(oslist=["linux"], archs=["i386"])
     def test_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
         self.inline_stepping()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_step_over_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
         self.inline_stepping_step_over()
     
     @add_test_categories(['pyapi'])
     def test_step_in_template_with_python_api(self):
         """Test stepping in to templated functions."""

lldb/trunk/packages/Python/lldbsuite/test/functionalities/memory/read/TestMemoryRead.py

class MemoryReadTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_memory_read(self):
         """Test the 'memory read' command with plain and vector formats."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break in main() aftre the variables are assigned values.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/control/TestMiExec.py

def test_lldbmi_exec_run(self):
         self.runCmd("-exec-run --start")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"signal-received\",signal-name=\"SIGSTOP\",signal-meaning=\"Stop\",.*?thread-id=\"1\",stopped-threads=\"all\"")
         # Test that lldb-mi is ready to execute next commands
         self.expect(self.child_prompt, exactly = True)
 
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_abort(self):
         """Test that 'lldb-mi --interpreter' works for -exec-abort."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -exec-abort fails on invalid process
         self.runCmd("-exec-abort")
         self.expect("\^error,msg=\"Command 'exec-abort'\. Invalid process during debug session\"")
def test_lldbmi_exec_abort(self):
 
         # Test that program may be aborted again
         self.runCmd("-exec-abort")
         self.expect("\^done")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_arguments_set(self):
         """Test that 'lldb-mi --interpreter' can pass args using -exec-arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_exec_arguments_set(self):
         self.expect("\"third_arg\"")
         #self.runCmd("-data-evaluate-expression argv[4]")
         #self.expect("\^done,value=\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
         self.runCmd("-interpreter-exec command \"print argv[4]\"")
         self.expect("\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
 
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_arguments_reset(self):
         """Test that 'lldb-mi --interpreter' can reset previously set args using -exec-arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_exec_next(self):
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-next --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailurei386 #xfail to get buildbot green, failing config: i386 binary running on ubuntu 14.04 x86_64
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_next_instruction(self):
         """Test that 'lldb-mi --interpreter' works for instruction stepping."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_exec_step_instruction(self):
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-step-instruction --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_finish(self):
         """Test that 'lldb-mi --interpreter' works for -exec-finish."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/variable/TestMiVar.py

 from lldbsuite.test.lldbtest import *
 
 class MiVarTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
-    @expectedFailureAll("llvm.org/pr23560", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_eval(self):
         """Test that 'lldb-mi --interpreter' works for evaluating."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

lldb/trunk/source/Plugins/Process/Utility/UnwindLLDB.h

private:
     std::vector<CursorSP> m_frames;
     CursorSP m_candidate_frame;
     bool m_unwind_complete; // If this is true, we've enumerated all the frames in the stack, and m_frames.size() is the 
                             // number of frames, etc.  Otherwise we've only gone as far as directly asked, and m_frames.size()
                             // is how far we've currently gone.
  
     std::vector<ConstString> m_user_supplied_trap_handler_functions;
 
+    //-----------------------------------------------------------------
+    // Check if Full UnwindPlan of First frame is valid or not.
+    // If not then try Fallback UnwindPlan of the frame. If Fallback
+    // UnwindPlan succeeds then update the Full UnwindPlan with the
+    // Fallback UnwindPlan.
+    //-----------------------------------------------------------------
+    void
+    UpdateUnwindPlanForFirstFrameIfInvalid (ABI* abi);
+
     CursorSP
     GetOneMoreFrame (ABI* abi);
 
     bool
     AddOneMoreFrame (ABI *abi);
 
     bool
     AddFirstFrame ();

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

 }
 
 bool
 UnwindLLDB::AddFirstFrame ()
 {
     if (m_frames.size() > 0)
         return true;
         
+    ProcessSP process_sp (m_thread.GetProcess());
+    ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
+
     // First, set up the 0th (initial) frame
     CursorSP first_cursor_sp(new Cursor ());
     RegisterContextLLDBSP reg_ctx_sp (new RegisterContextLLDB (m_thread, 
                                                                RegisterContextLLDBSP(), 
                                                                first_cursor_sp->sctx, 
                                                                0, *this));
     if (reg_ctx_sp.get() == NULL)
         goto unwind_done;
     
     if (!reg_ctx_sp->IsValid())
         goto unwind_done;
 
     if (!reg_ctx_sp->GetCFA (first_cursor_sp->cfa))
         goto unwind_done;
 
     if (!reg_ctx_sp->ReadPC (first_cursor_sp->start_pc))
         goto unwind_done;
 
     // Everything checks out, so release the auto pointer value and let the
     // cursor own it in its shared pointer
     first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
     m_frames.push_back (first_cursor_sp);
+
+    // Update the Full Unwind Plan for this frame if not valid
+    UpdateUnwindPlanForFirstFrameIfInvalid(abi);
+
     return true;
 
 unwind_done:
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
     if (log)
     {
         log->Printf ("th%d Unwind of this thread is complete.", m_thread.GetIndexID());
     }
if (cur_idx > 300000)
         return nullptr;
     }
 
     if (reg_ctx_sp.get() == NULL)
     {
         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+        {
+            // TryFallbackUnwindPlan for prev_frame succeeded and updated reg_ctx_lldb_sp field of
+            // prev_frame. However, cfa field of prev_frame still needs to be updated. Hence updating it.
+            if ( !(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
+                return nullptr;
+
             return GetOneMoreFrame (abi);
+        }
 
         if (log)
             log->Printf ("%*sFrame %d did not get a RegisterContext, stopping.",
                          cur_idx < 100 ? cur_idx : 100, "", cur_idx);
         return nullptr;
     }
 
     if (!reg_ctx_sp->IsValid())
     {
         // We failed to get a valid RegisterContext.
         // See if the regctx below this on the stack has a fallback unwind plan it can use.
         // Subsequent calls to TryFallbackUnwindPlan() will return false.
         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+        {
+            // TryFallbackUnwindPlan for prev_frame succeeded and updated reg_ctx_lldb_sp field of
+            // prev_frame. However, cfa field of prev_frame still needs to be updated. Hence updating it.
+            if ( !(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
+                return nullptr;
+
             return GetOneMoreFrame (abi);
+        }
 
         if (log)
             log->Printf("%*sFrame %d invalid RegisterContext for this frame, stopping stack walk", 
                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
         return nullptr;
     }
     if (!reg_ctx_sp->GetCFA (cursor_sp->cfa))
     {
         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+        {
+            // TryFallbackUnwindPlan for prev_frame succeeded and updated reg_ctx_lldb_sp field of
+            // prev_frame. However, cfa field of prev_frame still needs to be updated. Hence updating it.
+            if ( !(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
+                return nullptr;
+
             return GetOneMoreFrame (abi);
+        }
 
         if (log)
             log->Printf("%*sFrame %d did not get CFA for this frame, stopping stack walk",
                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
         return nullptr;
     }
     if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa))
     {
         // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not have
         // its (constructed) CFA aligned correctly -- don't do the abi alignment check for
         // these.
         if (reg_ctx_sp->IsTrapHandlerFrame() == false)
         {
             // See if we can find a fallback unwind plan for THIS frame.  It may be
             // that the UnwindPlan we're using for THIS frame was bad and gave us a
             // bad CFA.  
             // If that's not it, then see if we can change the UnwindPlan for the frame
             // below us ("NEXT") -- see if using that other UnwindPlan gets us a better
             // unwind state.
             if (reg_ctx_sp->TryFallbackUnwindPlan() == false
                 || reg_ctx_sp->GetCFA (cursor_sp->cfa) == false
                 || abi->CallFrameAddressIsValid(cursor_sp->cfa) == false)
             {
                 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+                {
+                    // TryFallbackUnwindPlan for prev_frame succeeded and updated reg_ctx_lldb_sp field of
+                    // prev_frame. However, cfa field of prev_frame still needs to be updated. Hence updating it.
+                    if ( !(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
+                        return nullptr;
+
                     return GetOneMoreFrame (abi);
+                }
 
                 if (log)
                     log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk",
                                 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
                 return nullptr;
             }
             else
             {
                 if (log)
                     log->Printf("%*sFrame %d had a bad CFA value but we switched the UnwindPlan being used and got one that looks more realistic.",
                                 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
             }
         }
     }
     if (!reg_ctx_sp->ReadPC (cursor_sp->start_pc))
     {
         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+        {
+            // TryFallbackUnwindPlan for prev_frame succeeded and updated reg_ctx_lldb_sp field of
+            // prev_frame. However, cfa field of prev_frame still needs to be updated. Hence updating it.
+            if ( !(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
+                return nullptr;
+
             return GetOneMoreFrame (abi);
+        }
 
         if (log)
             log->Printf("%*sFrame %d did not get PC for this frame, stopping stack walk",
                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
         return nullptr;
     }
     if (abi && !abi->CodeAddressIsValid (cursor_sp->start_pc))
     {
         // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
         // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
         if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+        {
+            // TryFallbackUnwindPlan for prev_frame succeeded and updated reg_ctx_lldb_sp field of
+            // prev_frame. However, cfa field of prev_frame still needs to be updated. Hence updating it.
+            if ( !(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
+                return nullptr;
+
             return GetOneMoreFrame (abi);
+        }
 
         if (log)
             log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk",
                         cur_idx < 100 ? cur_idx : 100, "", cur_idx);
         return nullptr;
     }
     // Infinite loop where the current cursor is the same as the previous one...
     if (prev_frame->start_pc == cursor_sp->start_pc && prev_frame->cfa == cursor_sp->cfa)
     {
         if (log)
             log->Printf ("th%d pc of this frame is the same as the previous frame and CFAs for both frames are identical -- stopping unwind", m_thread.GetIndexID());
         return nullptr;
     }
 
     cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
     return cursor_sp;
 }
 
+void
+UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid (ABI *abi)
+{
+    // This function is called for First Frame only.
+    assert (m_frames.size() == 1 && "No. of cursor frames are not 1");
+
+    bool old_m_unwind_complete = m_unwind_complete;
+    CursorSP old_m_candidate_frame = m_candidate_frame;
+
+    // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
+    // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also
+    // update the cfa of Frame 0 (if required).
+    AddOneMoreFrame(abi);
+
+    // Remove all the frames added by above function as the purpose of
+    // using above function was just to check whether Unwinder of Frame 0
+    // works or not.
+    for(uint32_t i=1; i<m_frames.size(); i++)
+        m_frames.pop_back();
+
+    // Restore status after calling AddOneMoreFrame
+    m_unwind_complete = old_m_unwind_complete;
+    m_candidate_frame = old_m_candidate_frame;
+    return;
+}
+
+
 bool
 UnwindLLDB::AddOneMoreFrame (ABI *abi)
 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 
     // Frame zero is a little different
     if (m_frames.empty())
         return false;
if (new_frame_v2 == nullptr)
         return true;
     }
 
     // Push the new frame to the list and try to continue from this frame. If we can get a new frame
     // then accept it as the correct one.
     m_frames.push_back(new_frame_v2);
     m_candidate_frame = GetOneMoreFrame(abi);
     if (m_candidate_frame)
+    {
+        // If control reached here then TryFallbackUnwindPlan had succeeded for Cursor::m_frames[m_frames.size() - 2].
+        // It also succeeded to Unwind next 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that.
+        // For Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already updated during TryFallbackUnwindPlan
+        // call above. However, cfa field still needs to be updated. Hence updating it here and then returning.
+        if ( !(m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(m_frames[m_frames.size() - 2]->cfa)))
+            return false;
         return true;
+    }
 
-    // The new frame isn't helped in unwinding. Fall back to the original one as the default unwind
+    // The new frame hasn't helped in unwinding. Fall back to the original one as the default unwind
     // plan is usually more reliable then the fallback one.
     m_frames.pop_back();
     m_frames.push_back(new_frame);
     return true;
 }
 
 bool
 UnwindLLDB::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc)