Add support for .ARM.exidx unwind information

[tberghammer]

Summary

.ARM.exidx/.ARM.extab sections contain unwind information used on ARM architecture from unwinding from an exception.

[labath]

I don't know much about the arm unwind info, but I have some style comments from a casual read-through.

include/lldb/Symbol/UnwindTable.h

71

unique pointers should have names ending in _up

source/Symbol/ArmUnwindInfo.cpp

62

Is there a reason DataExtractor::GetULEB128 could not be reused?

[jasonmolenda]

Looks good to me, I don't have anything beyond Pavel's suggestions. I don't know the format of the ARM .exidx .extab unwind info so I don't have any feedback on the parsing of that.

I forgot about that code in RegisterContextLLDB::GetFullUnwindPlanForFrame() for cases where we have no FuncUnwinders object. The comment on that,

// No FuncUnwinders available for this pc (i.e. a stripped function symbol and -fomit-frame-pointer).
// Try using the eh_frame or the .ARM.exidx information relative to the current PC,
// and finally fall back on the architectural default unwind.

could be a little clearer. I'd describe it more like

No FuncUnwinders available for this pc (stripped function symbols, lldb could not augment
its function table with another source, like LC_FUNCTION_STARTS or eh_frame in ObjectFileMachO).
See if eh_frame or the .ARM.exidx tables have unwind information for this address, else
fall back to the architectural default unwind.

ObjectFileMachO.cpp reads the symbols for the object file and then augments those with the
LC_FUNCTION_STARTS (a raw list of start addresses for the the functions in the binary) or the
eh_frame function ranges. Having accurate function start addresses is critical for the instruction
profile unwinding.

Compact unwind format is not suitable for a source of function start addresses -- if two functions
have the same unwind signature and exist next to each other in the binary, compact unwind may
represent them as a single entry, etc. The ARM unwind formats may have the same behavior.

Anyway, that's something the ObjectFile reader for your platform would need to do and not
the topic of this patch.

BTW "Implemnted based on" -> "Implemented based on". And thanks for including the
reference name / revision / URL - that kind of pointer is a huge help for long-term maintenance.

[jasonmolenda]

LGTM.

[tberghammer]

source/Symbol/ArmUnwindInfo.cpp

62

DataExtractor is reading from a stream of bytes while the arm unwind info is encoded in a bit more complicated (and strange way). It is encoded as a list of 4 byte words and then the 1 byte values have to be read from it from the MSB byte to the LSB byte what isn't match with the order used by the DataExtractor.

include/lldb/Symbol/ArmUnwindInfo.h

+//===-- ArmUnwindInfo.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ArmUnwindInfo_h_
+#define liblldb_ArmUnwindInfo_h_
+
+#include <vector>
+
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/RangeMap.h"
+#include "lldb/Host/Mutex.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/lldb-private.h"
+
+/*
+ * Unwind information reader and parser for the ARM exception handling ABI
+ *
+ * Implemnted based on:
+ *     Exception Handling ABI for the ARM® Architecture
+ *     Document number: ARM IHI 0038A (current through ABI r2.09)
+ *     Date of Issue: 25th January 2007, reissued 30th November 2012
+ *     http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf
+ */
+
+namespace lldb_private {
+
+class ArmUnwindInfo
+{
+public:
+    ArmUnwindInfo (ObjectFile& objfile, lldb::SectionSP& arm_exidx, lldb::SectionSP& arm_extab);
+    ~ArmUnwindInfo();
+
+    bool
+    GetUnwindPlan (Target &target, const Address& addr, UnwindPlan& unwind_plan);
+
+private:
+    const uint8_t*
+    GetExceptionHandlingTableEntry(const Address& addr);
+    
+    lldb::SectionSP m_arm_exidx_sp; // .ARM.exidx section
+    lldb::SectionSP m_arm_extab_sp; // .ARM.extab section
+
+    DataExtractor m_arm_exidx_data; // .ARM.exidx section data
+    DataExtractor m_arm_extab_data; // .ARM.extab section data
+};
+
+} // namespace lldb_private
+
+#endif  // liblldb_ArmUnwindInfo_h_

include/lldb/Symbol/FuncUnwinders.h

public:
 
     lldb::UnwindPlanSP
     GetEHFrameAugmentedUnwindPlan (Target &target, Thread &thread, int current_offset);
 
     lldb::UnwindPlanSP
     GetCompactUnwindUnwindPlan (Target &target, int current_offset);
 
     lldb::UnwindPlanSP
+    GetArmUnwindUnwindPlan (Target &target, int current_offset);
+
+    lldb::UnwindPlanSP
     GetArchDefaultUnwindPlan (Thread &thread);
 
     lldb::UnwindPlanSP
     GetArchDefaultAtFuncEntryUnwindPlan (Thread &thread);
 
 private:
 
     lldb::UnwindAssemblySP
     GetUnwindAssemblyProfiler (Target& target);
 
     UnwindTable& m_unwind_table;
     AddressRange m_range;
 
     Mutex m_mutex;
 
     lldb::UnwindPlanSP              m_unwind_plan_assembly_sp;
     lldb::UnwindPlanSP              m_unwind_plan_eh_frame_sp;
     lldb::UnwindPlanSP              m_unwind_plan_eh_frame_augmented_sp;   // augmented by assembly inspection so it's valid everywhere
     std::vector<lldb::UnwindPlanSP> m_unwind_plan_compact_unwind;
+    lldb::UnwindPlanSP              m_unwind_plan_arm_unwind_sp;
     lldb::UnwindPlanSP              m_unwind_plan_fast_sp;
     lldb::UnwindPlanSP              m_unwind_plan_arch_default_sp;
     lldb::UnwindPlanSP              m_unwind_plan_arch_default_at_func_entry_sp;
 
     // Fetching the UnwindPlans can be expensive - if we've already attempted
     // to get one & failed, don't try again.
     bool m_tried_unwind_plan_assembly:1,
          m_tried_unwind_plan_eh_frame:1,
          m_tried_unwind_plan_eh_frame_augmented:1,
          m_tried_unwind_plan_compact_unwind:1,
+         m_tried_unwind_plan_arm_unwind:1,
          m_tried_unwind_fast:1,
          m_tried_unwind_arch_default:1,
          m_tried_unwind_arch_default_at_func_entry:1;
 
     Address m_first_non_prologue_insn;
 
     DISALLOW_COPY_AND_ASSIGN (FuncUnwinders);
 
 }; // class FuncUnwinders
 
 } // namespace lldb_private
 
 
 #endif //liblldb_FuncUnwinders_h

include/lldb/Symbol/UnwindTable.h

public:
     ~UnwindTable();
 
     lldb_private::DWARFCallFrameInfo *
     GetEHFrameInfo ();
 
     lldb_private::CompactUnwindInfo *
     GetCompactUnwindInfo ();
 
+    ArmUnwindInfo *
+    GetArmUnwindInfo ();
+
     lldb::FuncUnwindersSP
     GetFuncUnwindersContainingAddress (const Address& addr, SymbolContext &sc);
 
 // Normally when we create a new FuncUnwinders object we track it in this UnwindTable so it can
 // be reused later.  But for the target modules show-unwind we want to create brand new 
 // UnwindPlans for the function of interest - so ignore any existing FuncUnwinders for that
 // function and don't add this new one to our UnwindTable.
 // This FuncUnwinders object does have a reference to the UnwindTable but the lifetime of this
private:
     typedef collection::const_iterator const_iterator;
 
     ObjectFile&         m_object_file;
     collection          m_unwinds;
 
     bool                m_initialized;  // delay some initialization until ObjectFile is set up
     Mutex               m_mutex;
 
-    DWARFCallFrameInfo* m_eh_frame;
-    CompactUnwindInfo  *m_compact_unwind;
-    
+    std::unique_ptr<DWARFCallFrameInfo> m_eh_frame;
+    std::unique_ptr<CompactUnwindInfo>  m_compact_unwind;
+    std::unique_ptr<ArmUnwindInfo>      m_arm_unwind;
     DISALLOW_COPY_AND_ASSIGN (UnwindTable);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_UnwindTable_h

include/lldb/lldb-enumerations.h

enum SectionType
         eSectionTypeDWARFAppleTypes,
         eSectionTypeDWARFAppleNamespaces,
         eSectionTypeDWARFAppleObjC,
         eSectionTypeELFSymbolTable,       // Elf SHT_SYMTAB section
         eSectionTypeELFDynamicSymbols,    // Elf SHT_DYNSYM section
         eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
         eSectionTypeELFDynamicLinkInfo,   // Elf SHT_DYNAMIC section
         eSectionTypeEHFrame,
+        eSectionTypeARMexidx,
+        eSectionTypeARMextab,
         eSectionTypeCompactUnwind,        // compact unwind section in Mach-O, __TEXT,__unwind_info
         eSectionTypeGoSymtab,
         eSectionTypeOther
     };
 
     FLAGS_ENUM(EmulateInstructionOptions)
     {
         eEmulateInstructionOptionNone               = (0u),

include/lldb/lldb-forward.h

 namespace lldb_private {
 
 class   ABI;
 class   Address;
 class   AddressImpl;
 class   AddressRange;
 class   AddressResolver;
 class   ArchSpec;
+class   ArmUnwindInfo;
 class   Args;
 class   ASTResultSynthesizer;
 class   ASTStructExtractor;
 class   Baton;
 class   Block;
 class   Breakpoint;
 class   BreakpointID;
 class   BreakpointIDList;

source/Commands/CommandObjectTarget.cpp

DoExecute (Args& command,
             UnwindPlanSP ehframe_augmented_sp = func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread.get(), 0);
             if (ehframe_augmented_sp)
             {
                 result.GetOutputStream().Printf("eh_frame augmented UnwindPlan:\n");
                 ehframe_augmented_sp->Dump(result.GetOutputStream(), thread.get(), LLDB_INVALID_ADDRESS);
                 result.GetOutputStream().Printf("\n");
             }
 
+            UnwindPlanSP arm_unwind_sp = func_unwinders_sp->GetArmUnwindUnwindPlan(*target, 0);
+            if (arm_unwind_sp)
+            {
+                result.GetOutputStream().Printf("ARM.exidx unwind UnwindPlan:\n");
+                arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(), LLDB_INVALID_ADDRESS);
+                result.GetOutputStream().Printf("\n");
+            }
+
             UnwindPlanSP compact_unwind_sp = func_unwinders_sp->GetCompactUnwindUnwindPlan(*target, 0);
             if (compact_unwind_sp)
             {
                 result.GetOutputStream().Printf("Compact unwind UnwindPlan:\n");
                 compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(), LLDB_INVALID_ADDRESS);
                 result.GetOutputStream().Printf("\n");
             }
 

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (!m_sections_ap.get() && ParseSectionHeaders())
             static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets");
             static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo");
             static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo");
             static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo");
             static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo");
             static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo");
             static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo");
             static ConstString g_sect_name_eh_frame (".eh_frame");
+            static ConstString g_sect_name_arm_exidx (".ARM.exidx");
+            static ConstString g_sect_name_arm_extab (".ARM.extab");
             static ConstString g_sect_name_go_symtab (".gosymtab");
 
             SectionType sect_type = eSectionTypeOther;
 
             bool is_thread_specific = false;
 
             if      (name == g_sect_name_text)                  sect_type = eSectionTypeCode;
             else if (name == g_sect_name_data)                  sect_type = eSectionTypeData;
if (!m_sections_ap.get() && ParseSectionHeaders())
             else if (name == g_sect_name_dwarf_debug_str_offsets)     sect_type = eSectionTypeDWARFDebugStrOffsets;
             else if (name == g_sect_name_dwarf_debug_abbrev_dwo)      sect_type = eSectionTypeDWARFDebugAbbrev;
             else if (name == g_sect_name_dwarf_debug_info_dwo)        sect_type = eSectionTypeDWARFDebugInfo;
             else if (name == g_sect_name_dwarf_debug_line_dwo)        sect_type = eSectionTypeDWARFDebugLine;
             else if (name == g_sect_name_dwarf_debug_loc_dwo)         sect_type = eSectionTypeDWARFDebugLoc;
             else if (name == g_sect_name_dwarf_debug_str_dwo)         sect_type = eSectionTypeDWARFDebugStr;
             else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets;
             else if (name == g_sect_name_eh_frame)                    sect_type = eSectionTypeEHFrame;
+            else if (name == g_sect_name_arm_exidx)                   sect_type = eSectionTypeARMexidx;
+            else if (name == g_sect_name_arm_extab)                   sect_type = eSectionTypeARMextab;
             else if (name == g_sect_name_go_symtab)                   sect_type = eSectionTypeGoSymtab;
 
             switch (header.sh_type)
             {
                 case SHT_SYMTAB:
                     assert (sect_type == eSectionTypeOther);
                     sect_type = eSectionTypeELFSymbolTable;
                     break;

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (symtab)
                     case eSectionTypeDWARFDebugStrOffsets:
                     case eSectionTypeDWARFAppleNames:
                     case eSectionTypeDWARFAppleTypes:
                     case eSectionTypeDWARFAppleNamespaces:
                     case eSectionTypeDWARFAppleObjC:
                         return eAddressClassDebug;
 
                     case eSectionTypeEHFrame:
+                    case eSectionTypeARMexidx:
+                    case eSectionTypeARMextab:
                     case eSectionTypeCompactUnwind:
                         return eAddressClassRuntime;
 
                     case eSectionTypeELFSymbolTable:
                     case eSectionTypeELFDynamicSymbols:
                     case eSectionTypeELFRelocationEntries:
                     case eSectionTypeELFDynamicLinkInfo:
                     case eSectionTypeOther:

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
RegisterContextLLDB::GetFullUnwindPlanForFrame ()
 
     FuncUnwindersSP func_unwinders_sp;
     if (m_sym_ctx_valid)
     {
         func_unwinders_sp = pc_module_sp->GetObjectFile()->GetUnwindTable().GetFuncUnwindersContainingAddress (m_current_pc, m_sym_ctx);
     }
 
     // No FuncUnwinders available for this pc (i.e. a stripped function symbol and -fomit-frame-pointer).
-    // Try using the eh_frame information relative to the current PC,
+    // Try using the eh_frame or the .ARM.exidx information relative to the current PC,
     // and finally fall back on the architectural default unwind.
     if (!func_unwinders_sp)
     {
-        DWARFCallFrameInfo *eh_frame = pc_module_sp && pc_module_sp->GetObjectFile() ? 
-            pc_module_sp->GetObjectFile()->GetUnwindTable().GetEHFrameInfo() : nullptr;
-
         m_frame_type = eNormalFrame;
-        if (eh_frame && m_current_pc.IsValid())
+
+        if (!pc_module_sp || !pc_module_sp->GetObjectFile() || !m_current_pc.IsValid())
+            return arch_default_unwind_plan_sp;
+
+        // Even with -fomit-frame-pointer, we can try eh_frame to get back on track.
+        DWARFCallFrameInfo *eh_frame = pc_module_sp->GetObjectFile()->GetUnwindTable().GetEHFrameInfo();
+        if (eh_frame)
         {
             unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
-            // Even with -fomit-frame-pointer, we can try eh_frame to get back on track.
             if (eh_frame->GetUnwindPlan (m_current_pc, *unwind_plan_sp))
                 return unwind_plan_sp;
             else
                 unwind_plan_sp.reset();
         }
+
+        ArmUnwindInfo *arm_exidx = pc_module_sp->GetObjectFile()->GetUnwindTable().GetArmUnwindInfo();
+        if (arm_exidx)
+        {
+            unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
+            if (arm_exidx->GetUnwindPlan (exe_ctx.GetTargetRef(), m_current_pc, *unwind_plan_sp))
+                return unwind_plan_sp;
+            else
+                unwind_plan_sp.reset();
+        }
+
         return arch_default_unwind_plan_sp;
     }
 
     // If we're in _sigtramp(), unwinding past this frame requires special knowledge.  On Mac OS X this knowledge
     // is properly encoded in the eh_frame section, so prefer that if available.
     // On other platforms we may need to provide a platform-specific UnwindPlan which encodes the details of
     // how to unwind out of sigtramp.
     if (m_frame_type == eTrapHandlerFrame && process)

source/Symbol/ArmUnwindInfo.cpp

+//===-- ArmUnwindInfo.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <vector>
+
+#include "lldb/Core/Module.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Symbol/ArmUnwindInfo.h"
+#include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "Utility/ARM_DWARF_Registers.h"
+
+/*
+ * Unwind information reader and parser for the ARM exception handling ABI
+ *
+ * Implemnted based on:
+ *     Exception Handling ABI for the ARM Architecture
+ *     Document number: ARM IHI 0038A (current through ABI r2.09)
+ *     Date of Issue: 25th January 2007, reissued 30th November 2012
+ *     http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf
+ */
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace
+{
+    struct ArmExidxEntry
+    {
+        uint32_t address;
+        uint32_t data;
+    };
+};
+
+ArmUnwindInfo::ArmUnwindInfo(ObjectFile& objfile, SectionSP& arm_exidx, SectionSP& arm_extab) :
+    m_arm_exidx_sp(arm_exidx),
+    m_arm_extab_sp(arm_extab)
+{
+    objfile.ReadSectionData(arm_exidx.get(), m_arm_exidx_data);
+    objfile.ReadSectionData(arm_extab.get(), m_arm_extab_data);
+}
+
+ArmUnwindInfo::~ArmUnwindInfo()
+{
+}
+
+static uint8_t
+GetNextByte(const uint32_t* data, uint16_t offset)
+{
+    data += offset / 4;
+    offset = offset % 4;
+    return (data[0] >> ((3 - offset) * 8)) & 0xff;
+}
+
+static uint64_t
+GetULEB128(const uint32_t* data, uint16_t& offset, uint16_t max_offset)
+{
+    uint64_t result = 0;
+    uint8_t shift = 0;
+    while (offset < max_offset)
+    {
+        uint8_t byte = GetNextByte(data, offset++);
+        result |= (byte & 0x7f) << shift;
+        if ((byte & 0x80) == 0)
+            break;
+        shift += 7;
+    }
+    return result;
+}
+
+bool
+ArmUnwindInfo::GetUnwindPlan(Target &target, const Address& addr, UnwindPlan& unwind_plan)
+{
+    const uint32_t* data = (const uint32_t*)GetExceptionHandlingTableEntry(addr.GetFileAddress());
+    if (data == nullptr)
+        return false; // No unwind information for the function
+
+    if (data[0] == 0x1)
+        return false; // EXIDX_CANTUNWIND
+
+    uint16_t byte_count = 0;
+    uint16_t byte_offset = 0;
+    if (data[0] & 0x80000000)
+    {
+        switch ((data[0] >> 24) & 0x0f)
+        {
+            case 0:
+                byte_count = 4;
+                byte_offset = 1;
+                break;
+            case 1:
+            case 2:
+                byte_count = 4 * ((data[0] >> 16) & 0xff) + 4;
+                byte_offset = 2;
+                break;
+            default:
+                // Unhandled personality routine index
+                return false;
+        }
+    }
+    else
+    {
+        byte_count = 4 * ((data[1] >> 24) & 0xff) + 8;
+        byte_offset = 5;
+    }
+
+    uint8_t vsp_reg = dwarf_sp;
+    int32_t vsp = 0;
+    std::vector<std::pair<uint32_t, int32_t>> register_offsets; // register -> (offset from vsp_reg)
+
+    while (byte_offset < byte_count)
+    {
+        uint8_t byte1 = GetNextByte(data, byte_offset++);
+        if ((byte1&0xc0) == 0x00)
+        {
+            // 00xxxxxx
+            // vsp = vsp + (xxxxxx << 2) + 4. Covers range 0x04-0x100 inclusive
+            vsp += ((byte1 & 0x3f) << 2) + 4;
+        }
+        else if ((byte1&0xc0) == 0x40)
+        {
+            // 01xxxxxx
+            // vsp = vsp – (xxxxxx << 2) - 4. Covers range 0x04-0x100 inclusive
+            vsp -= ((byte1 & 0x3f) << 2) + 4;
+        }
+        else if ((byte1&0xf0) == 0x80)
+        {
+            if (byte_offset >= byte_count)
+                return false;
+
+            uint8_t byte2 = GetNextByte(data, byte_offset++);
+            if (byte1 == 0x80 && byte2 == 0)
+            {
+                // 10000000 00000000
+                // Refuse to unwind (for example, out of a cleanup) (see remark a)
+                return false;
+            }
+            else
+            {
+                // 1000iiii iiiiiiii (i not all 0)
+                // Pop up to 12 integer registers under masks {r15-r12}, {r11-r4} (see remark b)
+                uint16_t regs = ((byte1&0x0f) << 8) | byte2;
+                for (uint8_t i = 0; i < 12; ++i)
+                {
+                    if (regs & (1<<i))
+                    {
+                        register_offsets.emplace_back(dwarf_r4 + i, vsp);
+                        vsp += 4;
+                    }
+                }
+            }
+        }
+        else if ((byte1&0xff) == 0x9d)
+        {
+            // 10011101
+            // Reserved as prefix for ARM register to register moves
+            return false;
+        }
+        else if ((byte1&0xff) == 0x9f)
+        {
+            // 10011111
+            // Reserved as prefix for Intel Wireless MMX register to register moves
+            return false;
+        }
+        else if ((byte1&0xf0) == 0x90)
+        {
+            // 1001nnnn (nnnn != 13,15)
+            // Set vsp = r[nnnn]
+            vsp_reg = dwarf_r0 + (byte1&0x0f);
+        }
+        else if ((byte1&0xf8) == 0xa0)
+        {
+            // 10100nnn
+            // Pop r4-r[4+nnn]
+            uint8_t n = byte1&0x7;
+            for (uint8_t i = 0; i <= n; ++i)
+            {
+                register_offsets.emplace_back(dwarf_r4 + i, vsp);
+                vsp += 4;
+            }
+        }
+        else if ((byte1&0xf8) == 0xa8)
+        {
+            // 10101nnn
+            // Pop r4-r[4+nnn], r14
+            uint8_t n = byte1&0x7;
+            for (uint8_t i = 0; i <= n; ++i)
+            {
+                register_offsets.emplace_back(dwarf_r4 + i, vsp);
+                vsp += 4;
+            }
+
+            register_offsets.emplace_back(dwarf_lr, vsp);
+            vsp += 4;
+        }
+        else if ((byte1&0xff) == 0xb0)
+        {
+            // 10110000
+            // Finish (see remark c)
+            break;
+        }
+        else if ((byte1&0xff) == 0xb1)
+        {
+            if (byte_offset >= byte_count)
+                return false;
+
+            uint8_t byte2 = GetNextByte(data, byte_offset++);
+            if ((byte2&0xff) == 0x00)
+            {
+                // 10110001 00000000
+                // Spare (see remark f)
+                return false;
+            }
+            else if ((byte2&0xf0) == 0x00)
+            {
+                // 10110001 0000iiii (i not all 0)
+                // Pop integer registers under mask {r3, r2, r1, r0}
+                for (uint8_t i = 0; i < 4; ++i)
+                {
+                    if (byte2 & (1<<i))
+                    {
+                        register_offsets.emplace_back(dwarf_r0 + i, vsp);
+                        vsp += 4;
+                    }
+                }
+            }
+            else
+            {
+                // 10110001 xxxxyyyy
+                // Spare (xxxx != 0000)
+                return false;
+            }
+        }
+        else if ((byte1&0xff) == 0xb2)
+        {
+            // 10110010 uleb128
+            // vsp = vsp + 0x204+ (uleb128 << 2)
+            uint64_t uleb128 = GetULEB128(data, byte_offset, byte_count);
+            vsp += 0x204 + (uleb128 << 2);
+        }
+        else if ((byte1&0xff) == 0xb3)
+        {
+            // 10110011 sssscccc
+            // Pop VFP double-precision registers D[ssss]-D[ssss+cccc] saved (as if) by FSTMFDX (see remark d)
+            if (byte_offset >= byte_count)
+                return false;
+
+            uint8_t byte2 = GetNextByte(data, byte_offset++);
+            uint8_t s = (byte2&0xf0) >> 4;
+            uint8_t c = (byte2&0x0f) >> 0;
+            for (uint8_t i = 0; i <= c; ++i)
+            {
+                register_offsets.emplace_back(dwarf_d0 + s + i, vsp);
+                vsp += 8;
+            }
+            vsp += 4;
+        }
+        else if ((byte1&0xfc) == 0xb4)
+        {
+            // 101101nn
+            // Spare (was Pop FPA)
+            return false;
+        }
+        else if ((byte1&0xf8) == 0xb8)
+        {
+            // 10111nnn
+            // Pop VFP double-precision registers D[8]-D[8+nnn] saved (as if) by FSTMFDX (see remark d)
+            uint8_t n = byte1&0x07;
+            for (uint8_t i = 0; i <= n; ++i)
+            {
+                register_offsets.emplace_back(dwarf_d8 + i, vsp);
+                vsp += 8;
+            }
+            vsp += 4;
+        }
+        else if ((byte1&0xf8) == 0xc0)
+        {
+            // 11000nnn (nnn != 6,7)
+            // Intel Wireless MMX pop wR[10]-wR[10+nnn]
+
+            // 11000110 sssscccc
+            // Intel Wireless MMX pop wR[ssss]-wR[ssss+cccc] (see remark e)
+
+            // 11000111 00000000
+            // Spare
+
+            // 11000111 0000iiii
+            // Intel Wireless MMX pop wCGR registers under mask {wCGR3,2,1,0}
+
+            // 11000111 xxxxyyyy
+            // Spare (xxxx != 0000)
+
+            return false;
+        }
+        else if ((byte1&0xff) == 0xc8)
+        {
+            // 11001000 sssscccc
+            // Pop VFP double precision registers D[16+ssss]-D[16+ssss+cccc] saved (as if) by FSTMFDD (see remarks d,e)
+            if (byte_offset >= byte_count)
+                return false;
+
+            uint8_t byte2 = GetNextByte(data, byte_offset++);
+            uint8_t s = (byte2&0xf0) >> 4;
+            uint8_t c = (byte2&0x0f) >> 0;
+            for (uint8_t i = 0; i <= c; ++i)
+            {
+                register_offsets.emplace_back(dwarf_d16 + s + i, vsp);
+                vsp += 8;
+            }
+        }
+        else if ((byte1&0xff) == 0xc9)
+        {
+            // 11001001 sssscccc
+            // Pop VFP double precision registers D[ssss]-D[ssss+cccc] saved (as if) by FSTMFDD (see remark d)
+            if (byte_offset >= byte_count)
+                return false;
+
+            uint8_t byte2 = GetNextByte(data, byte_offset++);
+            uint8_t s = (byte2&0xf0) >> 4;
+            uint8_t c = (byte2&0x0f) >> 0;
+            for (uint8_t i = 0; i <= c; ++i)
+            {
+                register_offsets.emplace_back(dwarf_d0 + s + i, vsp);
+                vsp += 8;
+            }
+        }
+        else if ((byte1&0xf8) == 0xc8)
+        {
+            // 11001yyy
+            // Spare (yyy != 000, 001)
+            return false;
+        }
+        else if ((byte1&0xf8) == 0xc0)
+        {
+            // 11010nnn
+            // Pop VFP double-precision registers D[8]-D[8+nnn] saved (as if) by FSTMFDD (see remark d)
+            uint8_t n = byte1&0x07;
+            for (uint8_t i = 0; i <= n; ++i)
+            {
+                register_offsets.emplace_back(dwarf_d8 + i, vsp);
+                vsp += 8;
+            }
+        }
+        else if ((byte1&0xc0) == 0xc0)
+        {
+            // 11xxxyyy Spare (xxx != 000, 001, 010)
+            return false;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    UnwindPlan::RowSP row = std::make_shared<UnwindPlan::Row>();
+    row->SetOffset(0);
+    row->GetCFAValue().SetIsRegisterPlusOffset(vsp_reg, vsp);
+    
+    bool have_location_for_pc = false;
+    for (const auto& offset : register_offsets)
+    {
+        have_location_for_pc |= offset.first == dwarf_pc;
+        row->SetRegisterLocationToAtCFAPlusOffset(offset.first, offset.second - vsp, true);
+    }
+    
+    if (!have_location_for_pc)
+    {
+        UnwindPlan::Row::RegisterLocation lr_location;
+        if (row->GetRegisterInfo(dwarf_lr, lr_location))
+            row->SetRegisterInfo(dwarf_pc, lr_location);
+    }
+
+    unwind_plan.AppendRow(row);
+    unwind_plan.SetSourceName ("ARM.exidx unwind info");
+    unwind_plan.SetSourcedFromCompiler (eLazyBoolYes);
+    unwind_plan.SetUnwindPlanValidAtAllInstructions (eLazyBoolNo);
+    unwind_plan.SetRegisterKind (eRegisterKindDWARF);
+
+    return true;
+}
+
+const uint8_t*
+ArmUnwindInfo::GetExceptionHandlingTableEntry(const Address& addr)
+{
+    uint32_t file_addr = addr.GetFileAddress();
+    uint32_t exidx_base_addr = m_arm_exidx_sp->GetFileAddress();
+
+    const ArmExidxEntry* exidx_start = (const ArmExidxEntry*)m_arm_exidx_data.GetDataStart();
+    uint32_t bs_start = 0, bs_end = m_arm_exidx_data.GetByteSize() / sizeof(ArmExidxEntry);
+    while (bs_start + 1 < bs_end)
+    {
+        uint32_t mid = (bs_start + bs_end) / 2;
+        uint32_t mid_addr = exidx_base_addr + exidx_start[mid].address + mid * sizeof(ArmExidxEntry);
+        mid_addr &= 0x7fffffff;
+        if (mid_addr > file_addr)
+            bs_end = mid;
+        else
+            bs_start = mid;
+    }
+
+    uint32_t exidx_addr = exidx_base_addr +
+                          exidx_start[bs_start].address +
+                          bs_start * sizeof(ArmExidxEntry);
+    exidx_addr &= 0x7fffffff;
+    if (exidx_addr > file_addr)
+        return nullptr;
+
+    if (exidx_start[bs_start].data == 0x1)
+        return nullptr; // EXIDX_CANTUNWIND
+
+    if (exidx_start[bs_start].data & 0x80000000)
+        return (const uint8_t*)&exidx_start[bs_start].data;
+
+    uint32_t data_file_addr = exidx_base_addr +
+                              8 * bs_start + 4 +
+                              exidx_start[bs_start].data;
+    data_file_addr &= 0x7fffffff;
+    return m_arm_extab_data.GetDataStart() + (data_file_addr - m_arm_extab_sp->GetFileAddress());
+}

source/Symbol/CMakeLists.txt

 add_lldb_library(lldbSymbol
+  ArmUnwindInfo.cpp
   Block.cpp
   ClangASTContext.cpp
   ClangASTImporter.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangExternalASTSourceCommon.cpp
   CompilerDecl.cpp
   CompilerDeclContext.cpp
   CompilerType.cpp

source/Symbol/FuncUnwinders.cpp

 //===-- FuncUnwinders.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Symbol/FuncUnwinders.h"
+#include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/CompactUnwindInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"

 FuncUnwinders::FuncUnwinders (UnwindTable& unwind_table, AddressRange range) : 
     m_unwind_table (unwind_table), 
     m_range (range), 
     m_mutex (Mutex::eMutexTypeRecursive),
     m_unwind_plan_assembly_sp (),
     m_unwind_plan_eh_frame_sp (),
     m_unwind_plan_eh_frame_augmented_sp (),
     m_unwind_plan_compact_unwind (),
+    m_unwind_plan_arm_unwind_sp (),
     m_unwind_plan_fast_sp (), 
     m_unwind_plan_arch_default_sp (), 
     m_unwind_plan_arch_default_at_func_entry_sp (),
     m_tried_unwind_plan_assembly (false),
     m_tried_unwind_plan_eh_frame (false),
     m_tried_unwind_plan_eh_frame_augmented (false),
     m_tried_unwind_plan_compact_unwind (false),
+    m_tried_unwind_plan_arm_unwind (false),
     m_tried_unwind_fast (false),
     m_tried_unwind_arch_default (false),
     m_tried_unwind_arch_default_at_func_entry (false),
     m_first_non_prologue_insn ()
 {
 }
 
 //------------------------------------------------
 /// destructor
 //------------------------------------------------
 
 FuncUnwinders::~FuncUnwinders ()
 { 
 }
 
 UnwindPlanSP
 FuncUnwinders::GetUnwindPlanAtCallSite (Target &target, int current_offset)
 {
     Mutex::Locker locker (m_mutex);
 
     UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan (target, current_offset);
-    if (unwind_plan_sp.get() == nullptr)
-    {
-        unwind_plan_sp = GetCompactUnwindUnwindPlan (target, current_offset);
-    }
+    if (unwind_plan_sp)
+        return unwind_plan_sp;
+
+    if (unwind_plan_sp)
+        return unwind_plan_sp;
 
+    unwind_plan_sp = GetArmUnwindUnwindPlan (target, current_offset);
+    if (unwind_plan_sp)
         return unwind_plan_sp;
+
+    return nullptr;
 }
 
 UnwindPlanSP
 FuncUnwinders::GetCompactUnwindUnwindPlan (Target &target, int current_offset)
 {
     if (m_unwind_plan_compact_unwind.size() > 0)
         return m_unwind_plan_compact_unwind[0];    // FIXME support multiple compact unwind plans for one func
     if (m_tried_unwind_plan_compact_unwind)
if (m_range.GetBaseAddress().IsValid())
             if (!eh_frame->GetUnwindPlan (current_pc, *m_unwind_plan_eh_frame_sp))
                 m_unwind_plan_eh_frame_sp.reset();
         }
     }
     return m_unwind_plan_eh_frame_sp;
 }
 
 UnwindPlanSP
+FuncUnwinders::GetArmUnwindUnwindPlan (Target &target, int current_offset)
+{
+    if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
+        return m_unwind_plan_arm_unwind_sp;
+
+    Mutex::Locker lock (m_mutex);
+    m_tried_unwind_plan_arm_unwind = true;
+    if (m_range.GetBaseAddress().IsValid())
+    {
+        Address current_pc (m_range.GetBaseAddress ());
+        if (current_offset != -1)
+            current_pc.SetOffset (current_pc.GetOffset() + current_offset);
+        ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
+        if (arm_unwind_info)
+        {
+            m_unwind_plan_arm_unwind_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
+            if (!arm_unwind_info->GetUnwindPlan (target, current_pc, *m_unwind_plan_arm_unwind_sp))
+                m_unwind_plan_arm_unwind_sp.reset();
+        }
+    }
+    return m_unwind_plan_arm_unwind_sp;
+}
+
+UnwindPlanSP
 FuncUnwinders::GetEHFrameAugmentedUnwindPlan (Target &target, Thread &thread, int current_offset)
 {
     if (m_unwind_plan_eh_frame_augmented_sp.get() || m_tried_unwind_plan_eh_frame_augmented)
         return m_unwind_plan_eh_frame_augmented_sp;
 
     // Only supported on x86 architectures where we get eh_frame from the compiler that describes
     // the prologue instructions perfectly, and sometimes the epilogue instructions too.
     if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386

source/Symbol/ObjectFile.cpp

if (symtab)
                     case eSectionTypeDWARFDebugStr:
                     case eSectionTypeDWARFDebugStrOffsets:
                     case eSectionTypeDWARFAppleNames:
                     case eSectionTypeDWARFAppleTypes:
                     case eSectionTypeDWARFAppleNamespaces:
                     case eSectionTypeDWARFAppleObjC:
                         return eAddressClassDebug;
                     case eSectionTypeEHFrame:
+                    case eSectionTypeARMexidx:
+                    case eSectionTypeARMextab:
                     case eSectionTypeCompactUnwind:
                         return eAddressClassRuntime;
                     case eSectionTypeELFSymbolTable:
                     case eSectionTypeELFDynamicSymbols:
                     case eSectionTypeELFRelocationEntries:
                     case eSectionTypeELFDynamicLinkInfo:
                     case eSectionTypeOther:
                         return eAddressClassUnknown;

source/Symbol/UnwindTable.cpp

 #include <stdio.h>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
+#include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CompactUnwindInfo.h"
 
 // There is one UnwindTable object per ObjectFile.
 // It contains a list of Unwind objects -- one per function, populated lazily -- for the ObjectFile.
 // Each Unwind object has multiple UnwindPlans for different scenarios.
 
 using namespace lldb;
 using namespace lldb_private;
 
 UnwindTable::UnwindTable (ObjectFile& objfile) : 
     m_object_file (objfile), 
     m_unwinds (),
     m_initialized (false),
     m_mutex (),
-    m_eh_frame (nullptr),
-    m_compact_unwind (nullptr)
+    m_eh_frame (),
+    m_compact_unwind (),
+    m_arm_unwind ()
 {
 }
 
 // We can't do some of this initialization when the ObjectFile is running its ctor; delay doing it
 // until needed for something.
 
 void
 UnwindTable::Initialize ()
 {
     if (m_initialized)
         return;
 
     Mutex::Locker locker(m_mutex);
 
     if (m_initialized) // check again once we've acquired the lock
         return;
 
     SectionList* sl = m_object_file.GetSectionList ();
     if (sl)
     {
         SectionSP sect = sl->FindSectionByType (eSectionTypeEHFrame, true);
         if (sect.get())
         {
-            m_eh_frame = new DWARFCallFrameInfo(m_object_file, sect, eRegisterKindEHFrame, true);
+            m_eh_frame.reset(new DWARFCallFrameInfo(m_object_file, sect, eRegisterKindEHFrame, true));
         }
         sect = sl->FindSectionByType (eSectionTypeCompactUnwind, true);
         if (sect.get())
         {
-            m_compact_unwind = new CompactUnwindInfo(m_object_file, sect);
+            m_compact_unwind.reset(new CompactUnwindInfo(m_object_file, sect));
+        }
+        sect = sl->FindSectionByType (eSectionTypeARMexidx, true);
+        if (sect.get())
+        {
+            SectionSP sect_extab = sl->FindSectionByType (eSectionTypeARMextab, true);
+            if (sect_extab.get())
+            {
+                m_arm_unwind.reset(new ArmUnwindInfo(m_object_file, sect, sect_extab));
+            }
         }
     }
     
     m_initialized = true;
 }
 
 UnwindTable::~UnwindTable ()
 {
-    if (m_eh_frame)
-        delete m_eh_frame;
 }
 
 FuncUnwindersSP
 UnwindTable::GetFuncUnwindersContainingAddress (const Address& addr, SymbolContext &sc)
 {
     FuncUnwindersSP no_unwind_found;
 
     Initialize();
UnwindTable::Dump (Stream &s)
     }
     s.EOL();
 }
 
 DWARFCallFrameInfo *
 UnwindTable::GetEHFrameInfo ()
 {
     Initialize();
-    return m_eh_frame;
+    return m_eh_frame.get();
 }
 
 CompactUnwindInfo *
 UnwindTable::GetCompactUnwindInfo ()
 {
     Initialize();
-    return m_compact_unwind;
+    return m_compact_unwind.get();
+}
+
+ArmUnwindInfo *
+UnwindTable::GetArmUnwindInfo ()
+{
+    Initialize();
+    return m_arm_unwind.get();
 }
 
 bool
 UnwindTable::GetArchitecture (lldb_private::ArchSpec &arch)
 {
     return m_object_file.GetArchitecture (arch);
 }

source/Utility/ConvertEnum.cpp

switch (sect_type)
         case eSectionTypeDWARFAppleTypes:
             return "apple-types";
         case eSectionTypeDWARFAppleNamespaces:
             return "apple-namespaces";
         case eSectionTypeDWARFAppleObjC:
             return "apple-objc";
         case eSectionTypeEHFrame:
             return "eh-frame";
+        case eSectionTypeARMexidx:
+            return "ARM.exidx";
+        case eSectionTypeARMextab:
+            return "ARM.extab";
         case eSectionTypeCompactUnwind:
             return "compact-unwind";
         case eSectionTypeGoSymtab:
             return "go-symtab";
         case eSectionTypeOther:
             return "regular";
     }
     return "unknown";
 }