[LLDB] Check that RegisterInfo and ContextInfo are trivial

[DavidSpickett]

Summary

RegisterInfo is often initialised with a memcpy, and ContextInfo
does not run destructors for anything within it.

This was discussed in https://reviews.llvm.org/D134041.

lldb/include/lldb/Core/EmulateInstruction.h

public:
   struct Context {
     ContextType type = eContextInvalid;
 
   private:
     enum InfoType info_type = eInfoTypeNoArgs;
 
   public:
     enum InfoType GetInfoType() const { return info_type; }
-    union {
+    union ContextInfo {
       struct RegisterPlusOffset {
         RegisterInfo reg;      // base register
         int64_t signed_offset; // signed offset added to base register
       } RegisterPlusOffset;
 
       struct RegisterPlusIndirectOffset {
         RegisterInfo base_reg;   // base register number
         RegisterInfo offset_reg; // offset register kind
union ContextInfo {
 
       struct ISAAndImmediateSigned {
         uint32_t isa;
         int32_t signed_data32; // signed immediate data
       } ISAAndImmediateSigned;
 
       uint32_t isa;
     } info;
+    static_assert(std::is_trivial<ContextInfo>::value,
+                  "ContextInfo must be trivial.");
 
     Context() = default;
 
     void SetRegisterPlusOffset(RegisterInfo base_reg, int64_t signed_offset) {
       info_type = eInfoTypeRegisterPlusOffset;
       info.RegisterPlusOffset.reg = base_reg;
       info.RegisterPlusOffset.signed_offset = signed_offset;
     }

lldb/include/lldb/lldb-private-types.h

 #define LLDB_LLDB_PRIVATE_TYPES_H
 
 #if defined(__cplusplus)
 
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
+#include <type_traits>
+
 namespace llvm {
 namespace sys {
 class DynamicLibrary;
 }
 }
 
 namespace lldb_private {
 class Platform;
llvm::ArrayRef<uint8_t> data(const uint8_t *context_base) const {
     return llvm::ArrayRef<uint8_t>(context_base + byte_offset, byte_size);
   }
 
   llvm::MutableArrayRef<uint8_t> mutable_data(uint8_t *context_base) const {
     return llvm::MutableArrayRef<uint8_t>(context_base + byte_offset,
                                           byte_size);
   }
 };
+static_assert(std::is_trivial<RegisterInfo>::value,
+              "RegisterInfo must be trivial.");
 
 /// Registers are grouped into register sets
 struct RegisterSet {
   /// Name of this register set.
   const char *name;
   /// A short name for this register set.
   const char *short_name;
   /// The number of registers in REGISTERS array below.