Fix prologue and epilogue handling in UnwindAssemblyInstEmulation

[tberghammer]

Summary

Fix prologue and epilogue handling in UnwindAssemblyInstEmulation

[tberghammer]

Added some inline comment to explain the reason behind each change

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

162–196

We have to create the new CFA row before processing the instruction following the return-to-caller instruction so it will be valid for the instruction immediately after the return-to-caller instruction and if the next instruction change the CFA then it have the correct base information.

This have to be done even if the current instruction will change the CFA row to have the right data for the current instruction.

175

When we create a new row from the saved prologue CFA row we should start it from the current instruction, not from the next one.

Previously it was:

m_curr_row->SetOffset (inst->GetAddress().GetFileAddress() + inst->GetOpcode().GetByteSize() - base_addr);

257–265

We have to save the prologue CFA also if the last instruction changed the CFA because when the following instruction is detected as part of the epilogue then the prologue CFA will never be saved.

641–642

eContextRegisterLoad can happen as part of the prologue when the value of some register is initialized with constants. On android-arm it is done by loading data from a PC relative address with the LDR instruction using the mixed code and data segments.

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

186–187

This variable only used to detect when we can't be in the prologue because of an instruction what should only appear in the epilogue. Rename it accordingly.

[tberghammer]

Friendly ping

[tberghammer]

Abandon because of an upcoming patch fixing this issue and several other issue also

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

UnwindAssemblyInstEmulation (const lldb_private::ArchSpec &arch,
         m_unwind_plan_ptr (NULL),
         m_curr_row (),
         m_cfa_reg_info (),
         m_fp_is_cfa (false),
         m_register_values (),
         m_pushed_regs(),
         m_curr_row_modified (false),
         m_curr_insn_is_branch_immediate (false),
-        m_curr_insn_restored_a_register (false)
+        m_curr_insn_part_of_epilogue (false)
     {
         if (m_inst_emulator_ap.get())
         {
             m_inst_emulator_ap->SetBaton (this);
             m_inst_emulator_ap->SetCallbacks (ReadMemory, WriteMemory, ReadRegister, WriteRegister);
         }
     }
 
//                size_t length);
     // While processing the instruction stream, we need to communicate some state change
     // information up to the higher level loop that makes decisions about how to push
     // the unwind instructions for the UnwindPlan we're constructing.
     
     // The instruction we're processing updated the UnwindPlan::Row contents
     bool m_curr_row_modified;
     // The instruction we're examining is a branch immediate instruction
     bool m_curr_insn_is_branch_immediate;
-    // The instruction we're processing restored a caller's reg value (e.g. in an epilogue)
-    bool m_curr_insn_restored_a_register;
+    // The instruction we're processing can only appear in the epilogue.
+    bool m_curr_insn_part_of_epilogue;
 };
 
 #endif // liblldb_UnwindAssemblyInstEmulation_h_

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

if (range.GetByteSize() > 0 &&
                 if (m_inst_emulator_ap->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA, ra_reg_info))
                     ra_reg_num = ra_reg_info.kinds[unwind_plan.GetRegisterKind()];
                 else
                     ra_reg_num = LLDB_INVALID_REGNUM;
 
                 for (size_t idx=0; idx<num_instructions; ++idx)
                 {
                     m_curr_row_modified = false;
-                    m_curr_insn_restored_a_register = false;
+                    m_curr_insn_part_of_epilogue = false;
                     inst = inst_list.GetInstructionAtIndex (idx).get();
                     if (inst)
                     {
                         if (log && log->GetVerbose ())
                         {
                             StreamString strm;
                             lldb_private::FormatEntity::Entry format;
                             FormatEntity::Parse("${frame.pc}: ", format);
                             inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize (), show_address, show_bytes, NULL, NULL, NULL, &format, 0);
                             log->PutCString (strm.GetData());
                         }
 
                         m_inst_emulator_ap->SetInstruction (inst->GetOpcode(), 
                                                             inst->GetAddress(), 
                                                             exe_ctx.GetTargetPtr());
 
                         m_inst_emulator_ap->EvaluateInstruction (eEmulateInstructionOptionIgnoreConditions);
 
+                        // If the previous instruction was a return-to-caller (epilogue), and we're still executing
+                        // instructions in this function, there must be a code path that jumps over that epilogue.
+                        // Also detect the case where we epilogue & branch imm to another function (tail-call opt)
+                        // instead of a normal pop lr-into-pc exit.
+                        // Reinstate the frame setup from the prologue.
+                        if (reinstate_prologue_next_instruction
+                            || (m_curr_insn_is_branch_immediate && last_instruction_restored_return_addr_reg))
+                        {
+                            if (log && log->GetVerbose())
+                                log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- Reinstating prologue instruction set");
+                            UnwindPlan::Row *newrow = new UnwindPlan::Row;
+                            *newrow = *prologue_completed_row.get();
+                            m_curr_row.reset(newrow);
+                            m_curr_row->SetOffset (inst->GetAddress().GetFileAddress() - base_addr);
+                            unwind_plan.AppendRow(m_curr_row);
+
+                            newrow = new UnwindPlan::Row;
+                            *newrow = *m_curr_row.get();
+                            m_curr_row.reset(newrow);
+
+                            reinstate_prologue_next_instruction = false;
+                            last_instruction_restored_return_addr_reg = false; 
+                            m_curr_insn_is_branch_immediate = false;
+                        }
+
+                        // clear both of these if either one wasn't set
+                        if (last_instruction_restored_return_addr_reg)
+                        {
+                            last_instruction_restored_return_addr_reg = false;
+                        }
+                        if (m_curr_insn_is_branch_immediate)
+                        {
+                            m_curr_insn_is_branch_immediate = false;
+                        }
+
                         // Were there any changes to the CFI while evaluating this instruction?
                         if (m_curr_row_modified)
                         {
                             reinstate_prologue_next_instruction = false;
                             m_curr_row->SetOffset (inst->GetAddress().GetFileAddress() + inst->GetOpcode().GetByteSize() - base_addr);
                             // Append the new row
                             unwind_plan.AppendRow (m_curr_row);
 
                             // Allocate a new Row for m_curr_row, copy the current state into it
                             UnwindPlan::Row *newrow = new UnwindPlan::Row;
                             *newrow = *m_curr_row.get();
                             m_curr_row.reset(newrow);
 
-                            // If m_curr_insn_restored_a_register == true, we're looking at an epilogue instruction.
-                            // Set instructions_since_last_prologue_insn to a very high number so we don't append 
+                            // If m_curr_insn_part_of_epilogue, we're looking at an epilogue instruction.
+                            // Set instructions_since_last_prologue_insn to a very high number so we don't append
                             // any of these epilogue instructions to our prologue_complete row.
-                            if (m_curr_insn_restored_a_register == false && instructions_since_last_prologue_insn < 8)
+                            if (m_curr_insn_part_of_epilogue == false && instructions_since_last_prologue_insn < 8)
                               instructions_since_last_prologue_insn = 0;
                             else
                               instructions_since_last_prologue_insn = 99;
 
                             UnwindPlan::Row::RegisterLocation pc_regloc;
                             UnwindPlan::Row::RegisterLocation ra_regloc;
 
                             // While parsing the instructions of this function, if we've ever
if (range.GetByteSize() > 0 &&
                                      && m_curr_row->GetRegisterInfo (ra_reg_num, ra_regloc)
                                      && ra_regloc.IsSame())
                             {
                                 if (log && log->GetVerbose())
                                     log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- lr is <same>, restore prologue instruction if the next instruction is a branch immediate.");
                                 last_instruction_restored_return_addr_reg = true;
                             }
                         }
-                        else
-                        {
-                            // If the previous instruction was a return-to-caller (epilogue), and we're still executing
-                            // instructions in this function, there must be a code path that jumps over that epilogue.
-                            // Also detect the case where we epilogue & branch imm to another function (tail-call opt)
-                            // instead of a normal pop lr-into-pc exit.
-                            // Reinstate the frame setup from the prologue.
-                            if (reinstate_prologue_next_instruction
-                                || (m_curr_insn_is_branch_immediate && last_instruction_restored_return_addr_reg))
-                            {
-                                if (log && log->GetVerbose())
-                                    log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- Reinstating prologue instruction set");
-                                UnwindPlan::Row *newrow = new UnwindPlan::Row;
-                                *newrow = *prologue_completed_row.get();
-                                m_curr_row.reset(newrow);
-                                m_curr_row->SetOffset (inst->GetAddress().GetFileAddress() + inst->GetOpcode().GetByteSize() - base_addr);
-                                unwind_plan.AppendRow(m_curr_row);
-
-                                newrow = new UnwindPlan::Row;
-                                *newrow = *m_curr_row.get();
-                                m_curr_row.reset(newrow);
-
-                                reinstate_prologue_next_instruction = false;
-                                last_instruction_restored_return_addr_reg = false; 
-                                m_curr_insn_is_branch_immediate = false;
-                            }
-
-                            // clear both of these if either one wasn't set
-                            if (last_instruction_restored_return_addr_reg)
-                            {
-                                last_instruction_restored_return_addr_reg = false;
-                            }
-                            if (m_curr_insn_is_branch_immediate)
-                            {
-                                m_curr_insn_is_branch_immediate = false;
-                            }
- 
-                            // Stop updating the prologue instructions if we've seen 8 non-prologue instructions
-                            // in a row.
-                            if (instructions_since_last_prologue_insn++ < 8)
-                            {
-                                UnwindPlan::Row *newrow = new UnwindPlan::Row;
-                                *newrow = *m_curr_row.get();
-                                prologue_completed_row.reset(newrow);
-                                if (log && log->GetVerbose())
-                                    log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- saving a copy of the current row as the prologue row.");
-                            }
-                        }
-                    }
-                }
-            }
             // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions.
             // I'll fix that but for now, just clear the list and it will go away nicely.
             disasm_sp->GetInstructionList().Clear();
         }
         
         if (log && log->GetVerbose ())
         {
             StreamString strm;
//            }
 
         case EmulateInstruction::eContextRegisterLoad:
             {
                 const uint32_t unwind_reg_kind = m_unwind_plan_ptr->GetRegisterKind();
                 const uint32_t reg_num = reg_info->kinds[unwind_reg_kind];
                 if (reg_num != LLDB_INVALID_REGNUM)
                 {
                     m_curr_row->SetRegisterLocationToRegister (reg_num, reg_num, must_replace);
                     m_curr_row_modified = true;
-                    m_curr_insn_restored_a_register = true;
 
                     if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_RA)
                     {
                         // This load was restoring the return address register,
                         // so this is also how we will unwind the PC...
                         RegisterInfo pc_reg_info;
                         if (instruction->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc_reg_info))
                         {
                             uint32_t pc_reg_num = pc_reg_info.kinds[unwind_reg_kind];
//            }
 
         case EmulateInstruction::eContextPopRegisterOffStack:
             {
                 const uint32_t reg_num = reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
                 if (reg_num != LLDB_INVALID_REGNUM)
                 {
                     m_curr_row->SetRegisterLocationToSame (reg_num, must_replace);
                     m_curr_row_modified = true;
-                    m_curr_insn_restored_a_register = true;
+                    m_curr_insn_part_of_epilogue = true;
                 }
             }
             break;
 
         case EmulateInstruction::eContextSetFramePointer:
             if (!m_fp_is_cfa)
             {
                 m_fp_is_cfa = true;