Add "support" for DW_CFA_GNU_args_size to the unwinder

[labath]

Summary

This adds the knowledge of the DW_CFA_GNU_args_size instruction to the eh_frame parsing code.
Right now it is ignored as I am unsure how is it supposed to be handled, but now we are at least
able to parse the rest of the FDE containing this instruction.

I also add a fix for a bug which was exposed by this instruction. Namely, a mismatched sequence
of remember/restore instructions in the input could cause us to pop an empty stack and crash. Now
we just log the error and ignore the offending instruction.

[jasonmolenda]

This is fine - is there a binary using this? I'd love to see the assembly code and a dump of the eh_frame CFI.

I googled around and didn't find much about DW_CFA_GNU_args_size but in the libunwind llvm sources (v. https://llvm.org/svn/llvm-project/libunwind/trunk/src/ ) it takes the uleb value and adjusts the stack pointer by that value?? I don't see why that wouldn't be encoded in the normal "CFA is sp + offset" type rule of eh_frame so it must not be quite that simple. lldb will probably unwind incorrectly if code built frameless (not using a frame pointer register) is encountered.

[labath]

In D22266#482626, @jasonmolenda wrote:

This is fine - is there a binary using this? I'd love to see the assembly code and a dump of the eh_frame CFI.

I googled around and didn't find much about DW_CFA_GNU_args_size but in the libunwind llvm sources (v. https://llvm.org/svn/llvm-project/libunwind/trunk/src/ ) it takes the uleb value and adjusts the stack pointer by that value?? I don't see why that wouldn't be encoded in the normal "CFA is sp + offset" type rule of eh_frame so it must not be quite that simple. lldb will probably unwind incorrectly if code built frameless (not using a frame pointer register) is encountered.

That's pretty much what I was able to figure out as well. I haven't managed to understand it's purpose either.

GCC 4.9 seems to produce this instruction fairly liberally. However, I was unable to get it to produce this instruction in an esp-based frame (which could mean that we don't need to handle it? I don't know..) In any case, I am attaching a reduced object file demonstrating it's use of this function

thread.o33 KBDownload

, so you should be able to get all the info you requested from it. If you are able to help us with this, it would be very appreciated. Let me know if there is anything else I can do to help you with that.

For reference, the approximate source code of the function which produced that attribute is:

    extern "C" void*
    execute_native_thread_routine(void* __p)
    {
      thread::_Impl_base* __t = static_cast<thread::_Impl_base*>(__p);
      thread::__shared_base_type __local;
      __local.swap(__t->_M_this_ptr);

	{
	  __t->_M_run();
	}

      return 0;
    }

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

DWARFCallFrameInfo::GetFDEIndex ()
     }
     m_fde_index.Sort();
     m_fde_index_initialized = true;
 }
 
 bool
 DWARFCallFrameInfo::FDEToUnwindPlan (dw_offset_t dwarf_offset, Address startaddr, UnwindPlan& unwind_plan)
 {
+    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND);
     lldb::offset_t offset = dwarf_offset;
     lldb::offset_t current_entry = offset;
 
     if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
         return false;
 
     if (m_cfi_data_initialized == false)
         GetCFIData();
while (m_cfi_data.ValidOffset(offset) && offset < end_offset)
                     {
                         // These instructions define a stack of information. Encountering the
                         // DW_CFA_remember_state instruction means to save the rules for every
                         // register on the current row on the stack. Encountering the
                         // DW_CFA_restore_state instruction means to pop the set of rules off
                         // the stack and place them in the current row. (This operation is
                         // useful for compilers that move epilogue code into the body of a
                         // function.)
+                        if (stack.empty())
+                        {
+                            if (log)
+                                log->Printf(
+                                    "DWARFCallFrameInfo::%s(dwarf_offset: %" PRIx32 ", startaddr: %" PRIx64
+                                    " encountered DW_CFA_restore_state but state stack is empty. Corrupt unwind info?",
+                                    __FUNCTION__, dwarf_offset, startaddr.GetFileAddress());
+                            break;
+                        }
                         lldb::addr_t offset = row->GetOffset ();
                         row = stack.back ();
                         stack.pop_back ();
                         row->SetOffset (offset);
                         break;
                     }
 
+                    case DW_CFA_GNU_args_size: // 0x2e
+                    {
+                        // The DW_CFA_GNU_args_size instruction takes an unsigned LEB128 operand
+                        // representing an argument size. This instruction specifies the total of
+                        // the size of the arguments which have been pushed onto the stack.
+
+                        // TODO: Figure out how we should handle this.
+                        m_cfi_data.GetULEB128(&offset);
+                    }
+
                     case DW_CFA_val_offset          :   // 0x14
                     case DW_CFA_val_offset_sf       :   // 0x15
                     default:
                         break;
                 }
             }
         }
     }