[LLDB] Make instruction emulation context type private

[DavidSpickett]

Summary

This is the first step to being able to handle non
trivial types in the union.

info_type effects the lifetime of the objects in the union,
so making it private means we know you have to call one of the
Set<...> functions to change it.

lldb/include/lldb/Core/EmulateInstruction.h

enum InfoType {
     eInfoTypeISAAndImmediate,
     eInfoTypeISAAndImmediateSigned,
     eInfoTypeISA,
     eInfoTypeNoArgs
   };
 
   struct Context {
     ContextType type = eContextInvalid;
+
+  private:
     enum InfoType info_type = eInfoTypeNoArgs;
+
+  public:
+    enum InfoType GetInfoType() const { return info_type; }
     union {
       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

lldb/source/Core/EmulateInstruction.cpp

case eContextReturnFromException:
     strm.PutCString("return from exception");
     break;
 
   default:
     strm.PutCString("unrecognized context.");
     break;
   }
 
-  switch (info_type) {
+  switch (GetInfoType()) {
   case eInfoTypeRegisterPlusOffset:
     strm.Printf(" (reg_plus_offset = %s%+" PRId64 ")",
                 info.RegisterPlusOffset.reg.name,
                 info.RegisterPlusOffset.signed_offset);
     break;
 
   case eInfoTypeRegisterPlusIndirectOffset:
     strm.Printf(" (reg_plus_reg = %s + %s)",

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

size_t UnwindAssemblyInstEmulation::WriteMemory(
   case EmulateInstruction::eContextReturnFromException:
   case EmulateInstruction::eContextPopRegisterOffStack:
   case EmulateInstruction::eContextAdjustStackPointer:
     break;
 
   case EmulateInstruction::eContextPushRegisterOnStack: {
     uint32_t reg_num = LLDB_INVALID_REGNUM;
     uint32_t generic_regnum = LLDB_INVALID_REGNUM;
-    assert(context.info_type ==
+    assert(context.GetInfoType() ==
                EmulateInstruction::eInfoTypeRegisterToRegisterPlusOffset &&
            "unhandled case, add code to handle this!");
     const uint32_t unwind_reg_kind = m_unwind_plan_ptr->GetRegisterKind();
     reg_num = context.info.RegisterToRegisterPlusOffset.data_reg
                   .kinds[unwind_reg_kind];
     generic_regnum = context.info.RegisterToRegisterPlusOffset.data_reg
                          .kinds[eRegisterKindGeneric];
 
case EmulateInstruction::eContextRegisterLoad:
     break;
 
   case EmulateInstruction::eContextArithmetic: {
     // If we adjusted the current frame pointer by a constant then adjust the
     // CFA offset
     // with the same amount.
     lldb::RegisterKind kind = m_unwind_plan_ptr->GetRegisterKind();
     if (m_fp_is_cfa && reg_info->kinds[kind] == m_cfa_reg_info.kinds[kind] &&
-        context.info_type == EmulateInstruction::eInfoTypeRegisterPlusOffset &&
+        context.GetInfoType() ==
+            EmulateInstruction::eInfoTypeRegisterPlusOffset &&
         context.info.RegisterPlusOffset.reg.kinds[kind] ==
             m_cfa_reg_info.kinds[kind]) {
       const int64_t offset = context.info.RegisterPlusOffset.signed_offset;
       m_curr_row->GetCFAValue().IncOffset(-1 * offset);
       m_curr_row_modified = true;
     }
   } break;
 
   case EmulateInstruction::eContextAbsoluteBranchRegister:
   case EmulateInstruction::eContextRelativeBranchImmediate: {
-    if (context.info_type == EmulateInstruction::eInfoTypeISAAndImmediate &&
+    if (context.GetInfoType() == EmulateInstruction::eInfoTypeISAAndImmediate &&
         context.info.ISAAndImmediate.unsigned_data32 > 0) {
       m_forward_branch_offset =
           context.info.ISAAndImmediateSigned.signed_data32;
-    } else if (context.info_type ==
+    } else if (context.GetInfoType() ==
                    EmulateInstruction::eInfoTypeISAAndImmediateSigned &&
                context.info.ISAAndImmediateSigned.signed_data32 > 0) {
       m_forward_branch_offset = context.info.ISAAndImmediate.unsigned_data32;
-    } else if (context.info_type == EmulateInstruction::eInfoTypeImmediate &&
+    } else if (context.GetInfoType() ==
+                   EmulateInstruction::eInfoTypeImmediate &&
                context.info.unsigned_immediate > 0) {
       m_forward_branch_offset = context.info.unsigned_immediate;
-    } else if (context.info_type ==
+    } else if (context.GetInfoType() ==
                    EmulateInstruction::eInfoTypeImmediateSigned &&
                context.info.signed_immediate > 0) {
       m_forward_branch_offset = context.info.signed_immediate;
     }
   } break;
 
   case EmulateInstruction::eContextPopRegisterOffStack: {
     const uint32_t reg_num =
         reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
     const uint32_t generic_regnum = reg_info->kinds[eRegisterKindGeneric];
     if (reg_num != LLDB_INVALID_REGNUM &&
         generic_regnum != LLDB_REGNUM_GENERIC_SP) {
-      switch (context.info_type) {
+      switch (context.GetInfoType()) {
       case EmulateInstruction::eInfoTypeAddress:
         if (m_pushed_regs.find(reg_num) != m_pushed_regs.end() &&
             context.info.address == m_pushed_regs[reg_num]) {
           m_curr_row->SetRegisterLocationToSame(reg_num,
                                                 false /*must_replace*/);
           m_curr_row_modified = true;
 
           // FP has been restored to its original value, we are back