Make the ArmUnwindInfo parsing code endian independent

[tberghammer]

Summary

Make the ArmUnwindInfo parsing code endian independent

[labath]

Looks good, after fixing some typos.

include/lldb/Symbol/ArmUnwindInfo.h

55 ↗

(On Diff #36103)

For consideration:
storing just the byte order instead of the whole ObjectFile. (if it's clear that the ObjectFile object outlives this object then I'm fine with this also).

source/Symbol/ArmUnwindInfo.cpp

58 ↗

(On Diff #36103)

s/Custome/Custom/
s/red/read/

66 ↗

(On Diff #36103)

s/data[0]/value ?

lldb/trunk/include/lldb/Symbol/ArmUnwindInfo.h

  *     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(const ObjectFile& objfile,
+                  lldb::SectionSP& arm_exidx,
+                  lldb::SectionSP& arm_extab);
+
     ~ArmUnwindInfo();
 
     bool
-    GetUnwindPlan (Target &target, const Address& addr, UnwindPlan& unwind_plan);
+    GetUnwindPlan(Target &target, const Address& addr, UnwindPlan& unwind_plan);
 
 private:
     const uint8_t*
     GetExceptionHandlingTableEntry(const Address& addr);
-    
+    uint8_t
+    GetByteAtOffset(const uint32_t* data, uint16_t offset) const;
+
+    uint64_t
+    GetULEB128(const uint32_t* data, uint16_t& offset, uint16_t max_offset) const;
+
+    const lldb::ByteOrder m_byte_order;
     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_

lldb/trunk/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/Host/Endian.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
  *

 {
     struct ArmExidxEntry
     {
         uint32_t address;
         uint32_t data;
     };
 };
 
-ArmUnwindInfo::ArmUnwindInfo(ObjectFile& objfile, SectionSP& arm_exidx, SectionSP& arm_extab) :
+ArmUnwindInfo::ArmUnwindInfo(const ObjectFile& objfile,
+                             SectionSP& arm_exidx,
+                             SectionSP& arm_extab) :
+    m_byte_order(objfile.GetByteOrder()),
     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;
+// Read a byte from the unwind instruction stream with the given offset.
+// Custom function is required because have to red in order of significance within their containing
+// word (most significant byte first) and in increasing word address order.
+uint8_t
+ArmUnwindInfo::GetByteAtOffset(const uint32_t* data, uint16_t offset) const
+{
+    uint32_t value = data[offset / 4];
+    if (m_byte_order != endian::InlHostByteOrder())
+        value = llvm::ByteSwap_32(value);
+    return (value >> ((3 - (offset % 4)) * 8)) & 0xff;
 }
 
-static uint64_t
-GetULEB128(const uint32_t* data, uint16_t& offset, uint16_t max_offset)
+uint64_t
+ArmUnwindInfo::GetULEB128(const uint32_t* data, uint16_t& offset, uint16_t max_offset) const
 {
     uint64_t result = 0;
     uint8_t shift = 0;
     while (offset < max_offset)
     {
-        uint8_t byte = GetNextByte(data, offset++);
+        uint8_t byte = GetByteAtOffset(data, offset++);
         result |= (byte & 0x7f) << shift;
         if ((byte & 0x80) == 0)
             break;
         shift += 7;
     }
     return result;
 }
 
ArmUnwindInfo::GetUnwindPlan(Target &target, const Address& addr, UnwindPlan& unwind_plan)
     }
 
     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++);
+        uint8_t byte1 = GetByteAtOffset(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++);
+            uint8_t byte2 = GetByteAtOffset(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
             {
while (byte_offset < byte_count)
             // Finish (see remark c)
             break;
         }
         else if ((byte1&0xff) == 0xb1)
         {
             if (byte_offset >= byte_count)
                 return false;
 
-            uint8_t byte2 = GetNextByte(data, byte_offset++);
+            uint8_t byte2 = GetByteAtOffset(data, byte_offset++);
             if ((byte2&0xff) == 0x00)
             {
                 // 10110001 00000000
                 // Spare (see remark f)
                 return false;
             }
             else if ((byte2&0xf0) == 0x00)
             {
while (byte_offset < byte_count)
         }
         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 byte2 = GetByteAtOffset(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;
while (byte_offset < byte_count)
         }
         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 byte2 = GetByteAtOffset(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 byte2 = GetByteAtOffset(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;
             }
         }