Very minimal non-8-bit byte support for diverse kalimba architectures

[mg11]

Summary

This diff contains some initial work in getting lldb to debug non-8-bit byte architectures (currently only CSRs kalimba 5 architecture). I appreciate that it won't interest non-CSR people greatly but I thought it polite to place up for review prior to commit.

Key points:

• target_byte_size is added to DataExtractor for subsequent use as a formatting hint
• target_byte_size is added to Section class, since section sizes are in host bytes, and hence a multiplier is required to calculate correct offsets
• ObjectFileELF.cpp slightly modified to create sections with correct bytesize (kalimba annoyingly has differing bytesizes in code and data)
• ObjectFile.cpp ReadSection modified regarding bytesizes and offsets
• CommandObjectMemory changed can to allocate larger read buffers for mentioned architectures and to advise DataExtractor accordingly
• DataExtractor when printing bytes, consume target_byte_size number of bytes from host buffer for each byte printed.

Other changes in the diff:

• removal eCore_kalimba enumerant (specify each kalimba variant separately)
• support better recognition of kalimba3/4/5
• In ArchSpec lie about kalimba 24-bit bytes. Say they are 32-bit since 24-bit bytes are much harder to express on regular Intel PC platforms etc.

This diff is very, very minimal regarding getting non-8-bit byte architectures supported in lldb. However, for me, the only practical way is to work incrementally - lldb is far too big to change in one go, in this area. For example, only the count option is currently supported for memory read, I've not looked in any depth at -f format options.

[jingham]

Greg is out on vacation for a week. This looks fairly straightforward. There used to be architectures with weird byte sizes like 9 or 12 bits - gdb had some support for this. Choosing to express the number of bits per byte as a multiple of 8 makes it impossible to support this situation. OTOH I'm not sure how much that matters now-a-days.

Jim

[mg11]

@Jim
Regarding architectures with bytes whose size aren't a multiple of 8-bits, I believe these must be rare beasts indeed nowadays. Apart a colleague mentioning a TI processor (TMS320C5517) and CCL/CSRs XAP processor, both of which are 16-bit, I know only of the Kalimba, as a current-day processor, with non-8-bit-bytes. Well, should any even more exotic creatures show up, then at least I'll have started to pace the way for them...

[domipheus]

In D5503#6, @mg11 wrote:

@Jim
Regarding architectures with bytes whose size aren't a multiple of 8-bits, I believe these must be rare beasts indeed nowadays. Apart a colleague mentioning a TI processor (TMS320C5517) and CCL/CSRs XAP processor, both of which are 16-bit, I know only of the Kalimba, as a current-day processor, with non-8-bit-bytes. Well, should any even more exotic creatures show up, then at least I'll have started to pace the way for them...

Indeed. I know of a few devices apart from Kalimba that have non 8bit bytes, but they are all at least multiples of 8-bits in byte implementation.

[clayborg]

Looks good.

[tfiala]

This review is mighty stale, but going through my differentials I saw it was still around. It looked good for the time.

[tfiala]

I'm going ahead and closing this one out. It either went in or is not interesting to the author any more. Last ping was over a couple weeks ago.

include/lldb/Core/ArchSpec.h

enum Core
         eCore_x86_64_x86_64h, // Haswell enabled x86_64
         eCore_hexagon_generic,
         eCore_hexagon_hexagonv4,
         eCore_hexagon_hexagonv5,
 
         eCore_uknownMach32,
         eCore_uknownMach64,
 
-        eCore_kalimba,
         eCore_kalimba3,
         eCore_kalimba4,
         eCore_kalimba5,
 
         kNumCores,
 
         kCore_invalid,
         // The following constants are used for wildcard matching only
enum Core
         kCore_x86_32_last   = eCore_x86_32_i686,
 
         kCore_x86_64_first  = eCore_x86_64_x86_64,
         kCore_x86_64_last   = eCore_x86_64_x86_64h,
 
         kCore_hexagon_first  = eCore_hexagon_generic,
         kCore_hexagon_last   = eCore_hexagon_hexagonv5,
 
-        kCore_kalimba_first = eCore_kalimba,
+        kCore_kalimba_first = eCore_kalimba3,
         kCore_kalimba_last = eCore_kalimba5
     };
 
     //------------------------------------------------------------------
     /// Default constructor.
     ///
     /// Default constructor that initializes the object with invalid
     /// cpu type and subtype values.

include/lldb/Core/DataExtractor.h

public:
     /// @param[in] data_length
     ///     The length in bytes of \a data.
     ///
     /// @param[in] byte_order
     ///     A byte order of the data that we are extracting from.
     ///
     /// @param[in] addr_size
     ///     A new address byte size value.
+    ///
+    /// @param[in] target_byte_size
+    ///     A size of a target byte in 8-bit host bytes
     //------------------------------------------------------------------
-    DataExtractor (const void* data, lldb::offset_t data_length, lldb::ByteOrder byte_order, uint32_t addr_size);
+    DataExtractor (const void* data, lldb::offset_t data_length, lldb::ByteOrder byte_order, uint32_t addr_size, uint32_t target_byte_size = 1);
 
     //------------------------------------------------------------------
     /// Construct with shared data.
     ///
     /// Copies the data shared pointer which adds a reference to the
     /// contained in \a data_sp. The shared data reference is reference
     /// counted to ensure the data lives as long as anyone still has a
     /// valid shared pointer to the data in \a data_sp.
     ///
     /// @param[in] data_sp
     ///     A shared pointer to data.
     ///
     /// @param[in] byte_order
     ///     A byte order of the data that we are extracting from.
     ///
     /// @param[in] addr_size
     ///     A new address byte size value.
+    ///
+    /// @param[in] target_byte_size
+    ///     A size of a target byte in 8-bit host bytes
     //------------------------------------------------------------------
-    DataExtractor (const lldb::DataBufferSP& data_sp, lldb::ByteOrder byte_order, uint32_t addr_size);
+    DataExtractor (const lldb::DataBufferSP& data_sp, lldb::ByteOrder byte_order, uint32_t addr_size, uint32_t target_byte_size = 1);
 
     //------------------------------------------------------------------
     /// Construct with a subset of \a data.
     ///
     /// Initialize this object with a subset of the data bytes in \a
     /// data. If \a data contains shared data, then a reference to the
     /// shared data will be added to ensure the shared data stays around
     /// as long as any objects have references to the shared data. The
     /// byte order value and the address size settings are copied from \a
     /// data. If \a offset is not a valid offset in \a data, then no
     /// reference to the shared data will be added. If there are not
     /// \a length bytes available in \a data starting at \a offset,
     /// the length will be truncated to contain as many bytes as
     /// possible.
     ///
     /// @param[in] data
     ///     Another DataExtractor object that contains data.
     ///
     /// @param[in] offset
     ///     The offset into \a data at which the subset starts.
     ///
     /// @param[in] length
     ///     The length in bytes of the subset of data.
+    ///
+    /// @param[in] target_byte_size
+    ///     A size of a target byte in 8-bit host bytes
     //------------------------------------------------------------------
-    DataExtractor (const DataExtractor& data, lldb::offset_t offset, lldb::offset_t length);
+    DataExtractor (const DataExtractor& data, lldb::offset_t offset, lldb::offset_t length, uint32_t target_byte_size = 1);
 
     DataExtractor (const DataExtractor& rhs);
     //------------------------------------------------------------------
     /// Assignment operator.
     ///
     /// Copies all data, byte order and address size settings from \a rhs into
     /// this object. If \a rhs contains shared data, a reference to that
     /// shared data will be added.
public:
 
     uint8_t
     GetU8_unchecked (lldb::offset_t *offset_ptr) const
     {
         uint8_t val = m_start[*offset_ptr];
         *offset_ptr += 1;
         return val;
     }
-    
     uint16_t
     GetU16_unchecked (lldb::offset_t *offset_ptr) const;
 
     uint32_t
     GetU32_unchecked (lldb::offset_t *offset_ptr) const;
 
     uint64_t
     GetU64_unchecked (lldb::offset_t *offset_ptr) const;
protected:
     //------------------------------------------------------------------
     // Member variables
     //------------------------------------------------------------------
     const uint8_t * m_start;        ///< A pointer to the first byte of data.
     const uint8_t * m_end;          ///< A pointer to the byte that is past the end of the data.
     lldb::ByteOrder m_byte_order;   ///< The byte order of the data we are extracting from.
     uint32_t m_addr_size;           ///< The address size to use when extracting pointers or addresses
     mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can be shared among multilple instances
+    const uint32_t m_target_byte_size;
 };
 
 } // namespace lldb_private
 
 #endif  // #if defined (__cplusplus)
 #endif  // #ifndef liblldb_DataExtractor_h_

include/lldb/Core/Section.h

Section (const lldb::ModuleSP &module_sp,
              lldb::user_id_t sect_id,
              const ConstString &name,
              lldb::SectionType sect_type,
              lldb::addr_t file_vm_addr,
              lldb::addr_t vm_size,
              lldb::offset_t file_offset,
              lldb::offset_t file_size,
              uint32_t log2align,
-             uint32_t flags);
+             uint32_t flags,
+             uint32_t target_byte_size = 1);
 
     // Create a section that is a child of parent_section_sp
     Section (const lldb::SectionSP &parent_section_sp,    // NULL for top level sections, non-NULL for child sections
              const lldb::ModuleSP &module_sp,
              ObjectFile *obj_file,
              lldb::user_id_t sect_id,
              const ConstString &name,
              lldb::SectionType sect_type,
              lldb::addr_t file_vm_addr,
              lldb::addr_t vm_size,
              lldb::offset_t file_offset,
              lldb::offset_t file_size,
              uint32_t log2align,
-             uint32_t flags);
+             uint32_t flags,
+             uint32_t target_byte_size = 1);
 
     ~Section ();
 
     static int
     Compare (const Section& a, const Section& b);
 
     bool
     ContainsFileAddress (lldb::addr_t vm_addr) const;
public:
     }
 
     void
     SetLog2Align(uint32_t align)
     {
         m_log2align = align;
     }
 
+    // Get the number of host bytes required to hold a target byte
+    uint32_t
+    GetTargetByteSize() const
+    {
+        return m_target_byte_size; 
+    }     
 
 protected:
 
     ObjectFile      *m_obj_file;        // The object file that data for this section should be read from
     lldb::SectionType m_type;           // The type of this section
     lldb::SectionWP m_parent_wp;        // Weak pointer to parent section
     ConstString     m_name;             // Name of this section
     lldb::addr_t    m_file_addr;        // The absolute file virtual address range of this section if m_parent == NULL,
                                         // offset from parent file virtual address if m_parent != NULL
     lldb::addr_t    m_byte_size;        // Size in bytes that this section will occupy in memory at runtime
     lldb::offset_t  m_file_offset;      // Object file offset (if any)
     lldb::offset_t  m_file_size;        // Object file size (can be smaller than m_byte_size for zero filled sections...)
     uint32_t        m_log2align;        // log_2(align) of the section (i.e. section has to be aligned to 2^m_log2align)
     SectionList     m_children;         // Child sections
     bool            m_fake:1,           // If true, then this section only can contain the address if one of its
                                         // children contains an address. This allows for gaps between the children
                                         // that are contained in the address range for this section, but do not produce
                                         // hits unless the children contain the address.
                     m_encrypted:1,      // Set to true if the contents are encrypted
                     m_thread_specific:1;// This section is thread specific
+    uint32_t        m_target_byte_size; // Some architectures have non-8-bit byte size. This is specified as
+                                        // as a multiple number of a host bytes   
 private:
     DISALLOW_COPY_AND_ASSIGN (Section);
 };
 
 
 } // namespace lldb_private
 
 #endif  // liblldb_Section_h_

source/Commands/CommandObjectMemory.cpp

#undef ALL_KEYWORDS
                 m_format_options = m_prev_format_options;
                 m_memory_options = m_prev_memory_options;
                 m_outfile_options = m_prev_outfile_options;
                 m_varobj_options = m_prev_varobj_options;
             }
         }
 
         size_t item_count = m_format_options.GetCountValue().GetCurrentValue();
-        size_t item_byte_size = m_format_options.GetByteSizeValue().GetCurrentValue();
+
+        // TODO For non-8-bit byte addressable architectures this needs to be
+        // revisited to fully support all lldb's range of formatting options.
+        // Furthermore code memory reads (for those architectures) will not
+        // be correctly formatted even w/o formatting options.
+        size_t item_byte_size =
+            target->GetArchitecture().GetDataByteSize() > 1 ?
+            target->GetArchitecture().GetDataByteSize() :
+            m_format_options.GetByteSizeValue().GetCurrentValue();
+
         const size_t num_per_line = m_memory_options.m_num_per_line.GetCurrentValue();
 
         if (total_byte_size == 0)
         {
             total_byte_size = item_count * item_byte_size;
             if (total_byte_size == 0)
                 total_byte_size = 32;
         }
#undef ALL_KEYWORDS
                 result.AppendErrorWithFormat("specify either the end address (0x%" PRIx64 ") or the count (--count %" PRIu64 "), not both.\n", end_addr, (uint64_t)item_count);
                 result.SetStatus(eReturnStatusFailed);
                 return false;
             }
 
             total_byte_size = end_addr - addr;
             item_count = total_byte_size / item_byte_size;
         }
-        
         uint32_t max_unforced_size = target->GetMaximumMemReadSize();
         
         if (total_byte_size > max_unforced_size && !m_memory_options.m_force)
         {
             result.AppendErrorWithFormat("Normally, \'memory read\' will not read over %" PRIu32 " bytes of data.\n",max_unforced_size);
             result.AppendErrorWithFormat("Please use --force to override this restriction just once.\n");
             result.AppendErrorWithFormat("or set target.max-memory-read-size if you will often need a larger limit.\n");
             return false;
#undef ALL_KEYWORDS
                 }
             }
             return true;
         }
 
         result.SetStatus(eReturnStatusSuccessFinishResult);
         DataExtractor data (data_sp, 
                             target->GetArchitecture().GetByteOrder(), 
-                            target->GetArchitecture().GetAddressByteSize());
+                            target->GetArchitecture().GetAddressByteSize(),
+                            target->GetArchitecture().GetDataByteSize());
         
         Format format = m_format_options.GetFormat();
         if ( ( (format == eFormatChar) || (format == eFormatCharPrintable) )
             && (item_byte_size != 1))
         {
             // if a count was not passed, or it is 1
             if (m_format_options.GetCountValue().OptionWasSet() == false || item_count == 1)
             {
#undef ALL_KEYWORDS
         }
 
         assert (output_stream);
         size_t bytes_dumped = data.Dump (output_stream,
                                          0,
                                          format,
                                          item_byte_size,
                                          item_count,
-                                         num_per_line,
+                                         num_per_line / target->GetArchitecture().GetDataByteSize(),
                                          addr,
                                          0,
                                          0,
                                          exe_scope);
         m_next_addr = addr + bytes_dumped;
         output_stream->EOL();
         return true;
     }

source/Core/ArchSpec.cpp

static const CoreDefinition g_core_definitions[] =
     { eByteOrderLittle, 8, 1, 15, llvm::Triple::x86_64 , ArchSpec::eCore_x86_64_x86_64h , "x86_64h"   },
     { eByteOrderLittle, 4, 4, 4, llvm::Triple::hexagon , ArchSpec::eCore_hexagon_generic,    "hexagon"   },
     { eByteOrderLittle, 4, 4, 4, llvm::Triple::hexagon , ArchSpec::eCore_hexagon_hexagonv4,  "hexagonv4" },
     { eByteOrderLittle, 4, 4, 4, llvm::Triple::hexagon , ArchSpec::eCore_hexagon_hexagonv5,  "hexagonv5" },
 
     { eByteOrderLittle, 4, 4, 4 , llvm::Triple::UnknownArch , ArchSpec::eCore_uknownMach32  , "unknown-mach-32" },
     { eByteOrderLittle, 8, 4, 4 , llvm::Triple::UnknownArch , ArchSpec::eCore_uknownMach64  , "unknown-mach-64" },
 
-    { eByteOrderLittle, 4, 1, 1 , llvm::Triple::kalimba , ArchSpec::eCore_kalimba  , "kalimba" },
     { eByteOrderBig   , 4, 1, 1 , llvm::Triple::kalimba , ArchSpec::eCore_kalimba3  , "kalimba3" },
     { eByteOrderLittle, 4, 1, 1 , llvm::Triple::kalimba , ArchSpec::eCore_kalimba4  , "kalimba4" },
     { eByteOrderLittle, 4, 1, 1 , llvm::Triple::kalimba , ArchSpec::eCore_kalimba5  , "kalimba5" }
 };
 
 // Ensure that we have an entry in the g_core_definitions for each core. If you comment out an entry above,
 // you will need to comment out the corresponding ArchSpec::Core enumeration.
 static_assert(sizeof(g_core_definitions) / sizeof(CoreDefinition) == ArchSpec::kNumCores, "make sure we have one core definition for each core");
static const ArchDefinitionEntry g_elf_arch_entries[] =
     { ArchSpec::eCore_ppc_generic     , llvm::ELF::EM_PPC    , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // PowerPC
     { ArchSpec::eCore_ppc64_generic   , llvm::ELF::EM_PPC64  , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // PowerPC64
     { ArchSpec::eCore_arm_generic     , llvm::ELF::EM_ARM    , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // ARM
     { ArchSpec::eCore_arm_aarch64     , llvm::ELF::EM_AARCH64, LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // ARM64
     { ArchSpec::eCore_sparc9_generic  , llvm::ELF::EM_SPARCV9, LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // SPARC V9
     { ArchSpec::eCore_x86_64_x86_64   , llvm::ELF::EM_X86_64 , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // AMD64
     { ArchSpec::eCore_mips64          , llvm::ELF::EM_MIPS   , LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // MIPS
     { ArchSpec::eCore_hexagon_generic , llvm::ELF::EM_HEXAGON, LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu }, // HEXAGON
-    { ArchSpec::eCore_kalimba ,         llvm::ELF::EM_CSR_KALIMBA, LLDB_INVALID_CPUTYPE, 0xFFFFFFFFu, 0xFFFFFFFFu },  // KALIMBA
-    { ArchSpec::eCore_kalimba3 ,        llvm::ELF::EM_CSR_KALIMBA, 3, 0xFFFFFFFFu, 0xFFFFFFFFu },  // KALIMBA
-    { ArchSpec::eCore_kalimba4 ,        llvm::ELF::EM_CSR_KALIMBA, 4, 0xFFFFFFFFu, 0xFFFFFFFFu },  // KALIMBA
-    { ArchSpec::eCore_kalimba5 ,        llvm::ELF::EM_CSR_KALIMBA, 5, 0xFFFFFFFFu, 0xFFFFFFFFu }  // KALIMBA
-
+    { ArchSpec::eCore_kalimba3 ,        llvm::ELF::EM_CSR_KALIMBA, llvm::Triple::KalimbaSubArch_v3, 0xFFFFFFFFu, 0xFFFFFFFFu },  // KALIMBA
+    { ArchSpec::eCore_kalimba4 ,        llvm::ELF::EM_CSR_KALIMBA, llvm::Triple::KalimbaSubArch_v4, 0xFFFFFFFFu, 0xFFFFFFFFu },  // KALIMBA
+    { ArchSpec::eCore_kalimba5 ,        llvm::ELF::EM_CSR_KALIMBA, llvm::Triple::KalimbaSubArch_v5, 0xFFFFFFFFu, 0xFFFFFFFFu }  // KALIMBA
 };
 
 static const ArchDefinition g_elf_arch_def = {
     eArchTypeELF,
     llvm::array_lengthof(g_elf_arch_entries),
     g_elf_arch_entries,
     "elf",
 };

 }
 
 uint32_t
 ArchSpec::GetDataByteSize () const
 {
     switch (m_core)
     {
     case eCore_kalimba3:
-        return 3;        
+        return 4;        
     case eCore_kalimba4:
         return 1;        
     case eCore_kalimba5:
-        return 3;
+        return 4;
     default:        
         return 1;        
     }
     return 1;
 }
 
 uint32_t
 ArchSpec::GetCodeByteSize () const
case ArchSpec::eCore_x86_64_x86_64h:
         if (!enforce_exact_match)
         {
             try_inverse = false;
             if (core2 == ArchSpec::eCore_x86_64_x86_64)
                 return true;
         }
         break;
 
-    case ArchSpec::eCore_kalimba:
-    case ArchSpec::eCore_kalimba3:
-    case ArchSpec::eCore_kalimba4:
-    case ArchSpec::eCore_kalimba5:
-        if (core2 >= ArchSpec::kCore_kalimba_first && core2 <= ArchSpec::kCore_kalimba_last)
-        {
-            return true;
-        }
-        break;
-
     case ArchSpec::eCore_arm_armv8:
         if (!enforce_exact_match)
         {
             if (core2 == ArchSpec::eCore_arm_arm64)
                 return true;
             if (core2 == ArchSpec::eCore_arm_aarch64)
                 return true;
             try_inverse = false;

source/Core/DataExtractor.cpp

 //----------------------------------------------------------------------
 // Default constructor.
 //----------------------------------------------------------------------
 DataExtractor::DataExtractor () :
     m_start     (NULL),
     m_end       (NULL),
     m_byte_order(lldb::endian::InlHostByteOrder()),
     m_addr_size (4),
-    m_data_sp   ()
+    m_data_sp   (),
+    m_target_byte_size(1)
 {
 }
 
 //----------------------------------------------------------------------
 // This constructor allows us to use data that is owned by someone else.
 // The data must stay around as long as this object is valid.
 //----------------------------------------------------------------------
-DataExtractor::DataExtractor (const void* data, offset_t length, ByteOrder endian, uint32_t addr_size) :
+DataExtractor::DataExtractor (const void* data, offset_t length, ByteOrder endian, uint32_t addr_size, uint32_t target_byte_size/*=1*/) :
     m_start     ((uint8_t*)data),
     m_end       ((uint8_t*)data + length),
     m_byte_order(endian),
     m_addr_size (addr_size),
-    m_data_sp   ()
+    m_data_sp   (),
+    m_target_byte_size(target_byte_size)
 {
 }
 
 //----------------------------------------------------------------------
 // Make a shared pointer reference to the shared data in "data_sp" and
 // set the endian swapping setting to "swap", and the address size to
 // "addr_size". The shared data reference will ensure the data lives
 // as long as any DataExtractor objects exist that have a reference to
 // this data.
 //----------------------------------------------------------------------
-DataExtractor::DataExtractor (const DataBufferSP& data_sp, ByteOrder endian, uint32_t addr_size) :
+DataExtractor::DataExtractor (const DataBufferSP& data_sp, ByteOrder endian, uint32_t addr_size, uint32_t target_byte_size/*=1*/) :
     m_start     (NULL),
     m_end       (NULL),
     m_byte_order(endian),
     m_addr_size (addr_size),
-    m_data_sp   ()
+    m_data_sp   (),
+    m_target_byte_size(target_byte_size)
 {
     SetData (data_sp);
 }
 
 //----------------------------------------------------------------------
 // Initialize this object with a subset of the data bytes in "data".
 // If "data" contains shared data, then a reference to this shared
 // data will added and the shared data will stay around as long
 // as any object contains a reference to that data. The endian
 // swap and address size settings are copied from "data".
 //----------------------------------------------------------------------
-DataExtractor::DataExtractor (const DataExtractor& data, offset_t offset, offset_t length) :
+DataExtractor::DataExtractor (const DataExtractor& data, offset_t offset, offset_t length, uint32_t target_byte_size/*=1*/) :
     m_start(NULL),
     m_end(NULL),
     m_byte_order(data.m_byte_order),
     m_addr_size(data.m_addr_size),
-    m_data_sp()
+    m_data_sp(),
+    m_target_byte_size(target_byte_size)
 {
     if (data.ValidOffset(offset))
     {
         offset_t bytes_available = data.GetByteSize() - offset;
         if (length > bytes_available)
             length = bytes_available;
         SetData(data, offset, length);
     }
 }
 
 DataExtractor::DataExtractor (const DataExtractor& rhs) :
     m_start (rhs.m_start),
     m_end (rhs.m_end),
     m_byte_order (rhs.m_byte_order),
     m_addr_size (rhs.m_addr_size),
-    m_data_sp (rhs.m_data_sp)
+    m_data_sp (rhs.m_data_sp),
+    m_target_byte_size(rhs.m_target_byte_size)
 {
 }
 
 //----------------------------------------------------------------------
 // Assignment operator
 //----------------------------------------------------------------------
 const DataExtractor&
 DataExtractor::operator= (const DataExtractor& rhs)
for (uint32_t count = 0; ValidOffset(offset) && count < item_count; ++count)
                 if (item_format == eFormatBytesWithASCII && offset > line_start_offset)
                 {
                     s->Printf("%*s", static_cast<int>((num_per_line - (offset - line_start_offset)) * 3 + 2), "");
                     Dump(s, line_start_offset, eFormatCharPrintable, 1, offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0, 0);
                 }
                 s->EOL();
             }
             if (base_addr != LLDB_INVALID_ADDRESS)
-                s->Printf ("0x%8.8" PRIx64 ": ", (uint64_t)(base_addr + (offset - start_offset)));
+                s->Printf ("0x%8.8" PRIx64 ": ",
+                    (uint64_t)(base_addr + (offset - start_offset)/m_target_byte_size  ));
+
             line_start_offset = offset;
         }
         else
         if (item_format != eFormatChar &&
             item_format != eFormatCharPrintable &&
             item_format != eFormatCharArray &&
             count > 0)
         {
for (uint32_t count = 0; ValidOffset(offset) && count < item_count; ++count)
             break;
 
         case eFormatBytes:
         case eFormatBytesWithASCII:
             for (i=0; i<item_byte_size; ++i)
             {
                 s->Printf ("%2.2x", GetU8(&offset));
             }
+
             // Put an extra space between the groups of bytes if more than one
             // is being dumped in a group (item_byte_size is more than 1).
             if (item_byte_size > 1)
                 s->PutChar(' ');
             break;
 
         case eFormatChar:
         case eFormatCharPrintable:

source/Core/Section.cpp

Section::Section (const ModuleSP &module_sp,
                   user_id_t sect_id,
                   const ConstString &name,
                   SectionType sect_type,
                   addr_t file_addr,
                   addr_t byte_size,
                   lldb::offset_t file_offset,
                   lldb::offset_t file_size,
                   uint32_t log2align,
-                  uint32_t flags) :
+                  uint32_t flags,
+                  uint32_t target_byte_size/*=1*/) :
     ModuleChild     (module_sp),
     UserID          (sect_id),
     Flags           (flags),
     m_obj_file      (obj_file),
     m_type          (sect_type),
     m_parent_wp     (),
     m_name          (name),
     m_file_addr     (file_addr),
     m_byte_size     (byte_size),
     m_file_offset   (file_offset),
     m_file_size     (file_size),
     m_log2align     (log2align),
     m_children      (),
     m_fake          (false),
     m_encrypted     (false),
-    m_thread_specific (false)
+    m_thread_specific (false),
+    m_target_byte_size(target_byte_size)
 {
 //    printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ", addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s\n",
 //            this, module_sp.get(), sect_id, file_addr, file_addr + byte_size, file_offset, file_offset + file_size, flags, name.GetCString());
 }
 
 Section::Section (const lldb::SectionSP &parent_section_sp,
                   const ModuleSP &module_sp,
                   ObjectFile *obj_file,
                   user_id_t sect_id,
                   const ConstString &name,
                   SectionType sect_type,
                   addr_t file_addr,
                   addr_t byte_size,
                   lldb::offset_t file_offset,
                   lldb::offset_t file_size,
                   uint32_t log2align,
-                  uint32_t flags) :
+                  uint32_t flags,
+                  uint32_t target_byte_size/*=1*/) :
     ModuleChild     (module_sp),
     UserID          (sect_id),
     Flags           (flags),
     m_obj_file      (obj_file),
     m_type          (sect_type),
     m_parent_wp     (),
     m_name          (name),
     m_file_addr     (file_addr),
     m_byte_size     (byte_size),
     m_file_offset   (file_offset),
     m_file_size     (file_size),
     m_log2align     (log2align),
     m_children      (),
     m_fake          (false),
     m_encrypted     (false),
-    m_thread_specific (false)
+    m_thread_specific (false),
+    m_target_byte_size(target_byte_size)
 {
 //    printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ", addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s.%s\n",
 //            this, module_sp.get(), sect_id, file_addr, file_addr + byte_size, file_offset, file_offset + file_size, flags, parent_section_sp->GetName().GetCString(), name.GetCString());
     if (parent_section_sp)
         m_parent_wp = parent_section_sp;
 }
 
 Section::~Section()

 bool
 Section::ContainsFileAddress (addr_t vm_addr) const
 {
     const addr_t file_addr = GetFileAddress();
     if (file_addr != LLDB_INVALID_ADDRESS)
     {
         if (file_addr <= vm_addr)
         {
-            const addr_t offset = vm_addr - file_addr;
+            const addr_t offset = (vm_addr - file_addr) *  m_target_byte_size;
             return offset < GetByteSize();
         }
     }
     return false;
 }
 
 int
 Section::Compare (const Section& a, const Section& b)

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 kalimbaVariantFromElfFlags(const elf::elf_word e_flags)
 {
     const uint32_t dsp_rev = e_flags & 0xFF;
     uint32_t kal_arch_variant = LLDB_INVALID_CPUTYPE;
     switch(dsp_rev)
     {
         // TODO(mg11) Support more variants
         case 10:
-            kal_arch_variant = 3;
+            kal_arch_variant = llvm::Triple::KalimbaSubArch_v3;
             break;
         case 14:
-            kal_arch_variant = 4;
+            kal_arch_variant = llvm::Triple::KalimbaSubArch_v4;
+            break;
+        case 17:
+        case 20:
+            kal_arch_variant = llvm::Triple::KalimbaSubArch_v5;
             break;
         default:
             break;           
     }
     return kal_arch_variant;
 }
 
 static uint32_t
 subTypeFromElfHeader(const elf::ELFHeader& header)
 {
     return
         llvm::ELF::EM_CSR_KALIMBA == header.e_machine ?
         kalimbaVariantFromElfFlags(header.e_flags) :
         LLDB_INVALID_CPUTYPE;
 }
 
+//! brief kalimbaSectionType
+//! The kalimba toolchain identifies a code section as being
+//! one with the SHT_PROGBITS set in the section sh_type and the top
+//! bit in the 32-bit address field set.
+static lldb::SectionType
+kalimbaSectionType(
+    const elf::ELFHeader& header,
+    const elf::ELFSectionHeader& sect_hdr)
+{
+    if (
+        llvm::ELF::EM_CSR_KALIMBA != header.e_machine ||
+        llvm::ELF::SHT_PROGBITS != sect_hdr.sh_type)
+    {
+        return eSectionTypeOther;
+    }
+
+    const lldb::addr_t KAL_CODE_BIT = 1 << 31;
+    return KAL_CODE_BIT & sect_hdr.sh_addr ?
+         eSectionTypeCode  : eSectionTypeData;
+}
+
 // Arbitrary constant used as UUID prefix for core files.
 const uint32_t
 ObjectFileELF::g_core_uuid_magic(0xE210C);
 
 //------------------------------------------------------------------
 // Static methods.
 //------------------------------------------------------------------
 void
if (!m_sections_ap.get() && ParseSectionHeaders())
                     sect_type = eSectionTypeELFRelocationEntries;
                     break;
                 case SHT_DYNAMIC:
                     assert (sect_type == eSectionTypeOther);
                     sect_type = eSectionTypeELFDynamicLinkInfo;
                     break;
             }
 
+            if (eSectionTypeOther == sect_type)
+            {
+                // the kalimba toolchain assumes that ELF section names are free-form. It does
+                // supports linkscripts which (can) give rise to various arbitarily named
+                // sections being "Code" or "Data". 
+                sect_type = kalimbaSectionType(m_header, header);
+            }
+
+            const uint32_t target_bytes_size =
+                eSectionTypeData == sect_type ? 
+                m_arch_spec.GetDataByteSize() :
+                    eSectionTypeCode == sect_type ?
+                    m_arch_spec.GetCodeByteSize() : 1;
+
             elf::elf_xword log2align = (header.sh_addralign==0)
                                         ? 0
                                         : llvm::Log2_64(header.sh_addralign);
             SectionSP section_sp (new Section(GetModule(),        // Module to which this section belongs.
                                               this,               // ObjectFile to which this section belongs and should read section data from.
                                               SectionIndex(I),    // Section ID.
                                               name,               // Section name.
                                               sect_type,          // Section type.
                                               header.sh_addr,     // VM address.
                                               vm_size,            // VM size in bytes of this section.
                                               header.sh_offset,   // Offset of this section in the file.
                                               file_size,          // Size of the section as found in the file.
                                               log2align,          // Alignment of the section
-                                              header.sh_flags));  // Flags for this section.
+                                              header.sh_flags,    // Flags for this section.
+                                              target_bytes_size));// Number of host bytes per target byte
 
             if (is_thread_specific)
                 section_sp->SetIsThreadSpecific (is_thread_specific);
             m_sections_ap->AddSection(section_sp);
         }
     }
 
     if (m_sections_ap.get())

source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

PlatformKalimba::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
     return success;
 }
 
 bool
 PlatformKalimba::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
     if (idx == 0)
     {
-        arch = ArchSpec("kalimba-csr-unknown");
+        arch = ArchSpec("kalimba3-csr-unknown");
+        return true;
+    }
+    if (idx == 1)
+    {
+        arch = ArchSpec("kalimba4-csr-unknown");
+        return true;
+    }
+    if (idx == 2)
+    {
+        arch = ArchSpec("kalimba5-csr-unknown");
         return true;
     }
     return false;
 }
 
 void
 PlatformKalimba::GetStatus (Stream &strm)
 {

source/Symbol/ObjectFile.cpp

ObjectFile::CopyData (lldb::offset_t offset, size_t length, void *dst) const
     // Note that the data remains in target byte order.
     return m_data.CopyData (offset, length, dst);
 }
 
 
 size_t
 ObjectFile::ReadSectionData (const Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len) const
 {
+    assert(section);
+    section_offset *= section->GetTargetByteSize();
+
     // If some other objectfile owns this data, pass this to them.
     if (section->GetObjectFile() != this)
         return section->GetObjectFile()->ReadSectionData (section, section_offset, dst, dst_len);
 
     if (IsInMemory())
     {
         ProcessSP process_sp (m_process_wp.lock());
         if (process_sp)