[IRMemoryMap] Shrink Allocation make it move-only (NFC)

[vsk]

Summary

Profiling data show that Allocation::operator= is hot (see the data
attached to the Phab review).

Reorder a few fields within Allocation to avoid implicit structure
padding and shrink the structure. This should make copies a bit cheaper.

Also, given that an Allocation contains a std::vector (by way of
DataBufferHeap), it's preferable to make it move-only instead of
permitting expensive copies. As an added benefit this allows us to have
a single Allocation constructor instead of two.

[vsk]

• Make Allocation move-only. This should prevent a std::vector copy in ::Malloc.

[davide]

Looks reasonable to me.

lldb/trunk/include/lldb/Expression/IRMemoryMap.h

 /// allocations still get made-up addresses.  If an inferior appears at some
 /// point, then those addresses need to be re-mapped.
 //----------------------------------------------------------------------
 class IRMemoryMap {
 public:
   IRMemoryMap(lldb::TargetSP target_sp);
   ~IRMemoryMap();
 
-  enum AllocationPolicy {
+  enum AllocationPolicy : uint8_t {
     eAllocationPolicyInvalid =
         0, ///< It is an error for an allocation to have this policy.
     eAllocationPolicyHostOnly, ///< This allocation was created in the host and
                                ///will never make it into the process.
     ///< It is an error to create other types of allocations while such
     ///allocations exist.
     eAllocationPolicyMirror, ///< The intent is that this allocation exist both
                              ///in the host and the process and have
protected:
   // This function should only be used if you know you are using the JIT. Any
   // other cases should use GetBestExecutionContextScope().
 
   lldb::ProcessWP &GetProcessWP() { return m_process_wp; }
 
 private:
   struct Allocation {
     lldb::addr_t
-        m_process_alloc; ///< The (unaligned) base for the remote allocation
+        m_process_alloc; ///< The (unaligned) base for the remote allocation.
     lldb::addr_t
-        m_process_start; ///< The base address of the allocation in the process
-    size_t m_size;       ///< The size of the requested allocation
-    uint32_t m_permissions; ///< The access permissions on the memory in the
-                            ///process.  In the host, the memory is always
-                            ///read/write.
-    uint8_t m_alignment;    ///< The alignment of the requested allocation
+        m_process_start; ///< The base address of the allocation in the process.
+    size_t m_size;       ///< The size of the requested allocation.
     DataBufferHeap m_data;
 
-    ///< Flags
+    /// Flags. Keep these grouped together to avoid structure padding.
     AllocationPolicy m_policy;
     bool m_leak;
+    uint8_t m_permissions; ///< The access permissions on the memory in the
+                           /// process. In the host, the memory is always
+                           /// read/write.
+    uint8_t m_alignment;   ///< The alignment of the requested allocation.
 
   public:
     Allocation(lldb::addr_t process_alloc, lldb::addr_t process_start,
                size_t size, uint32_t permissions, uint8_t alignment,
                AllocationPolicy m_policy);
 
-    Allocation()
-        : m_process_alloc(LLDB_INVALID_ADDRESS),
-          m_process_start(LLDB_INVALID_ADDRESS), m_size(0), m_permissions(0),
-          m_alignment(0), m_data(), m_policy(eAllocationPolicyInvalid),
-          m_leak(false) {}
+    DISALLOW_COPY_AND_ASSIGN(Allocation);
   };
 
+  static_assert(sizeof(Allocation) <=
+                    (4 * sizeof(lldb::addr_t)) + sizeof(DataBufferHeap),
+                "IRMemoryMap::Allocation is larger than expected");
+
   lldb::ProcessWP m_process_wp;
   lldb::TargetWP m_target_wp;
   typedef std::map<lldb::addr_t, Allocation> AllocationMap;
   AllocationMap m_allocations;
 
   lldb::addr_t FindSpace(size_t size);
   bool ContainsHostOnlyAllocations();
   AllocationMap::iterator FindAllocation(lldb::addr_t addr, size_t size);

lldb/trunk/source/Expression/IRMemoryMap.cpp

ExecutionContextScope *IRMemoryMap::GetBestExecutionContextScope() const {
   return NULL;
 }
 
 IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
                                     lldb::addr_t process_start, size_t size,
                                     uint32_t permissions, uint8_t alignment,
                                     AllocationPolicy policy)
     : m_process_alloc(process_alloc), m_process_start(process_start),
-      m_size(size), m_permissions(permissions), m_alignment(alignment),
-      m_policy(policy), m_leak(false) {
+      m_size(size), m_policy(policy), m_leak(false), m_permissions(permissions),
+      m_alignment(alignment) {
   switch (policy) {
   default:
     assert(0 && "We cannot reach this!");
   case eAllocationPolicyHostOnly:
   case eAllocationPolicyMirror:
     m_data.SetByteSize(size);
     break;
   case eAllocationPolicyProcessOnly:
if (process_sp) {
       return LLDB_INVALID_ADDRESS;
     }
     break;
   }
 
   lldb::addr_t mask = alignment - 1;
   aligned_address = (allocation_address + mask) & (~mask);
 
-  m_allocations[aligned_address] =
-      Allocation(allocation_address, aligned_address, allocation_size,
-                 permissions, alignment, policy);
+  m_allocations.emplace(
+      std::piecewise_construct, std::forward_as_tuple(aligned_address),
+      std::forward_as_tuple(allocation_address, aligned_address,
+                            allocation_size, permissions, alignment, policy));
 
   if (zero_memory) {
     Status write_error;
     std::vector<uint8_t> zero_buf(size, 0);
     WriteMemory(aligned_address, zero_buf.data(), size, write_error);
   }
 
   if (log) {