[JITLoaderGDB] Pack the jit entry struct according to the target arch.

[sivachandra]

This fixes an issue we are seeing with i386 JIT entry handling.

I have chosen a least disruptive change. However, since alignment is actually determined by the ABI, one could add some API to the ABI interface to determine the packing. However, it seemed like an overkill for doing something special only for i386.

[clayborg]

Looks fine. One other alternative is to get the type from the program if it exists in the debug info and explore the struct using ValueObject. This would get you out of the fixed alignment issue by using the debug info to get the info. If the debug info is missing, you can always fall back to this code. I will leave that up to you.

[sivachandra]

Explicitly set the alignment of the size field in the unpacked struct
to 8 bytes. This should take care of the case where in the host is i386
and the target is arm (for example).

[sivachandra]

Thanks for the quick review.
I will put this in for now. Will revisit if a need for an elaborate solution arises.

source/Plugins/JITLoader/GDB/JITLoaderGDB.h

private:
     SetJITBreakpoint(lldb_private::ModuleList &module_list);
 
     bool
     DidSetJITBreakpoint() const;
 
     bool
     ReadJITDescriptor(bool all_entries);
 
-    template <typename ptr_t>
+    template <typename ptr_t, bool packed>
     bool
     ReadJITDescriptorImpl(bool all_entries);
 
     static bool
     JITDebugBreakpointHit(void *baton,
                           lldb_private::StoppointCallbackContext *context,
                           lldb::user_id_t break_id,
                           lldb::user_id_t break_loc_id);

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 //------------------------------------------------------------------
 typedef enum
 {
     JIT_NOACTION = 0,
     JIT_REGISTER_FN,
     JIT_UNREGISTER_FN
 } jit_actions_t;
 
-template <typename ptr_t>
+template <typename ptr_t, bool packed_size>
 struct jit_code_entry
 {
     ptr_t    next_entry; // pointer
     ptr_t    prev_entry; // pointer
     ptr_t    symfile_addr; // pointer
-    uint64_t symfile_size;
+    uint64_t symfile_size __attribute__ ((aligned (8)));
 };
+
+template <typename ptr_t>
+struct jit_code_entry<ptr_t, true>
+{
+    ptr_t    next_entry; // pointer
+    ptr_t    prev_entry; // pointer
+    ptr_t    symfile_addr; // pointer
+    uint64_t symfile_size __attribute__ ((packed));
+};
+
 template <typename ptr_t>
 struct jit_descriptor
 {
     uint32_t version;
     uint32_t action_flag; // Values are jit_action_t
     ptr_t    relevant_entry; // pointer
     ptr_t    first_entry; // pointer
 };
for (uint32_t i = 0; i<num_sections; ++i)
         }
     }
 }
 
 bool
 JITLoaderGDB::ReadJITDescriptor(bool all_entries)
 {
     Target &target = m_process->GetTarget();
-    if (target.GetArchitecture().GetAddressByteSize() == 8)
-        return ReadJITDescriptorImpl<uint64_t>(all_entries);
+    const ArchSpec &arch_spec = target.GetArchitecture();
+    if (arch_spec.GetAddressByteSize() == 8)
+        return ReadJITDescriptorImpl<uint64_t, false>(all_entries);
+    else
+    {
+        ArchSpec::Core core = arch_spec.GetCore();
+        if (ArchSpec::kCore_x86_32_first <= core && core <= ArchSpec::kCore_x86_32_last)
+            return ReadJITDescriptorImpl<uint32_t, true>(all_entries);
         else
-        return ReadJITDescriptorImpl<uint32_t>(all_entries);
+            return ReadJITDescriptorImpl<uint32_t, false>(all_entries);
+    }
 }
 
-template <typename ptr_t>
+template <typename ptr_t, bool packed>
 bool
 JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries)
 {
     if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
         return false;
 
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
     Target &target = m_process->GetTarget();
JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries)
     if (all_entries)
     {
         jit_action = JIT_REGISTER_FN;
         jit_relevant_entry = (addr_t)jit_desc.first_entry;
     }
 
     while (jit_relevant_entry != 0)
     {
-        jit_code_entry<ptr_t> jit_entry;
+        jit_code_entry<ptr_t, packed> jit_entry;
         const size_t jit_entry_size = sizeof(jit_entry);
         bytes_read = m_process->DoReadMemory(jit_relevant_entry, &jit_entry, jit_entry_size, error);
         if (bytes_read != jit_entry_size || !error.Success())
         {
             if (log)
                 log->Printf(
                     "JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64,
                     __FUNCTION__, jit_relevant_entry);