[LLDB][AArch64] Move instruction emulation to optional GetRegisterInfo

[DavidSpickett]

Summary

Depends on D134539

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

bool EmulateInstructionARM64::EmulateADDSUBImm(const uint32_t opcode) {
   if (setflags) {
     m_emulated_pstate.N = proc_state.N;
     m_emulated_pstate.Z = proc_state.Z;
     m_emulated_pstate.C = proc_state.C;
     m_emulated_pstate.V = proc_state.V;
   }
 
   Context context;
-  RegisterInfo reg_info_Rn;
-  if (GetRegisterInfo(eRegisterKindLLDB, n, reg_info_Rn))
-    context.SetRegisterPlusOffset(reg_info_Rn, imm);
+  llvm::Optional<RegisterInfo> reg_info_Rn =
+      GetRegisterInfo(eRegisterKindLLDB, n);
+  if (reg_info_Rn)
+    context.SetRegisterPlusOffset(*reg_info_Rn, imm);
 
   if (n == GetFramePointerRegisterNumber() && d == gpr_sp_arm64 && !setflags) {
     // 'mov sp, fp' - common epilogue instruction, CFA is now in terms of the
     // stack pointer, instead of frame pointer.
     context.type = EmulateInstruction::eContextRestoreStackPointer;
   } else if ((n == gpr_sp_arm64 || n == GetFramePointerRegisterNumber()) &&
              d == gpr_sp_arm64 && !setflags) {
     context.type = EmulateInstruction::eContextAdjustStackPointer;
bool EmulateInstructionARM64::EmulateLDPSTP(const uint32_t opcode) {
   idx = LSL(llvm::SignExtend64<7>(imm7), scale);
   size = (integer)1 << scale;
   uint64_t datasize = size * 8;
   uint64_t address;
   uint64_t wb_address;
 
   RegisterValue data_Rt;
   RegisterValue data_Rt2;
-  RegisterInfo reg_info_base;
-  RegisterInfo reg_info_Rt;
-  RegisterInfo reg_info_Rt2;
-  if (!GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + n, reg_info_base))
+  llvm::Optional<RegisterInfo> reg_info_base =
+      GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + n);
+  if (!reg_info_base)
     return false;
 
+  llvm::Optional<RegisterInfo> reg_info_Rt;
+  llvm::Optional<RegisterInfo> reg_info_Rt2;
+
   if (vector) {
-    if (!GetRegisterInfo(eRegisterKindLLDB, fpu_d0_arm64 + t, reg_info_Rt))
-      return false;
-    if (!GetRegisterInfo(eRegisterKindLLDB, fpu_d0_arm64 + t2, reg_info_Rt2))
-      return false;
+    reg_info_Rt = GetRegisterInfo(eRegisterKindLLDB, fpu_d0_arm64 + t);
+    reg_info_Rt2 = GetRegisterInfo(eRegisterKindLLDB, fpu_d0_arm64 + t2);
   } else {
-    if (!GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + t, reg_info_Rt))
-      return false;
-    if (!GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + t2, reg_info_Rt2))
-      return false;
+    reg_info_Rt = GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + t);
+    reg_info_Rt2 = GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + t2);
   }
 
+  if (!reg_info_Rt || !reg_info_Rt2)
+    return false;
+
   bool success = false;
   if (n == 31) {
     // CheckSPAlignment();
     address =
         ReadRegisterUnsigned(eRegisterKindLLDB, gpr_sp_arm64, 0, &success);
   } else
     address =
         ReadRegisterUnsigned(eRegisterKindLLDB, gpr_x0_arm64 + n, 0, &success);
if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is
                                                          // or fp register
     {
       context_t.type = eContextPushRegisterOnStack;
       context_t2.type = eContextPushRegisterOnStack;
     } else {
       context_t.type = eContextRegisterStore;
       context_t2.type = eContextRegisterStore;
     }
-    context_t.SetRegisterToRegisterPlusOffset(reg_info_Rt, reg_info_base, 0);
-    context_t2.SetRegisterToRegisterPlusOffset(reg_info_Rt2, reg_info_base,
+    context_t.SetRegisterToRegisterPlusOffset(*reg_info_Rt, *reg_info_base, 0);
+    context_t2.SetRegisterToRegisterPlusOffset(*reg_info_Rt2, *reg_info_base,
                                                size);
 
-    if (!ReadRegister(&reg_info_Rt, data_Rt))
+    if (!ReadRegister(&(*reg_info_Rt), data_Rt))
       return false;
 
-    if (data_Rt.GetAsMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size,
+    if (data_Rt.GetAsMemoryData(&(*reg_info_Rt), buffer, reg_info_Rt->byte_size,
                                 eByteOrderLittle, error) == 0)
       return false;
 
-    if (!WriteMemory(context_t, address + 0, buffer, reg_info_Rt.byte_size))
+    if (!WriteMemory(context_t, address + 0, buffer, reg_info_Rt->byte_size))
       return false;
 
-    if (!ReadRegister(&reg_info_Rt2, data_Rt2))
+    if (!ReadRegister(&(*reg_info_Rt2), data_Rt2))
       return false;
 
-    if (data_Rt2.GetAsMemoryData(&reg_info_Rt2, buffer, reg_info_Rt2.byte_size,
-                                 eByteOrderLittle, error) == 0)
+    if (data_Rt2.GetAsMemoryData(&(*reg_info_Rt2), buffer,
+                                 reg_info_Rt2->byte_size, eByteOrderLittle,
+                                 error) == 0)
       return false;
 
     if (!WriteMemory(context_t2, address + size, buffer,
-                     reg_info_Rt2.byte_size))
+                     reg_info_Rt2->byte_size))
       return false;
   } break;
 
   case MemOp_LOAD: {
     if (n == 31 || n == GetFramePointerRegisterNumber()) // if this load is
                                                          // based off of the sp
                                                          // or fp register
     {
       context_t.type = eContextPopRegisterOffStack;
       context_t2.type = eContextPopRegisterOffStack;
     } else {
       context_t.type = eContextRegisterLoad;
       context_t2.type = eContextRegisterLoad;
     }
     context_t.SetAddress(address);
     context_t2.SetAddress(address + size);
 
     if (rt_unknown)
-      memset(buffer, 'U', reg_info_Rt.byte_size);
+      memset(buffer, 'U', reg_info_Rt->byte_size);
     else {
-      if (!ReadMemory(context_t, address, buffer, reg_info_Rt.byte_size))
+      if (!ReadMemory(context_t, address, buffer, reg_info_Rt->byte_size))
         return false;
     }
 
-    if (data_Rt.SetFromMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size,
-                                  eByteOrderLittle, error) == 0)
+    if (data_Rt.SetFromMemoryData(&(*reg_info_Rt), buffer,
+                                  reg_info_Rt->byte_size, eByteOrderLittle,
+                                  error) == 0)
       return false;
 
     if (!vector && is_signed && !data_Rt.SignExtend(datasize))
       return false;
 
-    if (!WriteRegister(context_t, &reg_info_Rt, data_Rt))
+    if (!WriteRegister(context_t, &(*reg_info_Rt), data_Rt))
       return false;
 
     if (!rt_unknown) {
       if (!ReadMemory(context_t2, address + size, buffer,
-                      reg_info_Rt2.byte_size))
+                      reg_info_Rt2->byte_size))
         return false;
     }
 
-    if (data_Rt2.SetFromMemoryData(&reg_info_Rt2, buffer,
-                                   reg_info_Rt2.byte_size, eByteOrderLittle,
+    if (data_Rt2.SetFromMemoryData(&(*reg_info_Rt2), buffer,
+                                   reg_info_Rt2->byte_size, eByteOrderLittle,
                                    error) == 0)
       return false;
 
     if (!vector && is_signed && !data_Rt2.SignExtend(datasize))
       return false;
 
-    if (!WriteRegister(context_t2, &reg_info_Rt2, data_Rt2))
+    if (!WriteRegister(context_t2, &(*reg_info_Rt2), data_Rt2))
       return false;
   } break;
 
   default:
     break;
   }
 
   if (wback) {
     if (wb_unknown)
       wb_address = LLDB_INVALID_ADDRESS;
     Context context;
     context.SetImmediateSigned(idx);
     if (n == 31)
       context.type = eContextAdjustStackPointer;
     else
       context.type = eContextAdjustBaseRegister;
-    WriteRegisterUnsigned(context, &reg_info_base, wb_address);
+    WriteRegisterUnsigned(context, &(*reg_info_base), wb_address);
   }
   return true;
 }
 
 template <EmulateInstructionARM64::AddrMode a_mode>
 bool EmulateInstructionARM64::EmulateLDRSTRImm(const uint32_t opcode) {
   uint32_t size = Bits32(opcode, 31, 30);
   uint32_t opc = Bits32(opcode, 23, 22);
address =
         ReadRegisterUnsigned(eRegisterKindLLDB, gpr_x0_arm64 + n, 0, &success);
 
   if (!success)
     return false;
 
   if (!postindex)
     address += offset;
 
-  RegisterInfo reg_info_base;
-  if (!GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + n, reg_info_base))
+  llvm::Optional<RegisterInfo> reg_info_base =
+      GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + n);
+  if (!reg_info_base)
     return false;
 
-  RegisterInfo reg_info_Rt;
-  if (!GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + t, reg_info_Rt))
+  llvm::Optional<RegisterInfo> reg_info_Rt =
+      GetRegisterInfo(eRegisterKindLLDB, gpr_x0_arm64 + t);
+  if (!reg_info_Rt)
     return false;
 
   Context context;
   switch (memop) {
   case MemOp_STORE:
     if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is
                                                          // based off of the sp
                                                          // or fp register
       context.type = eContextPushRegisterOnStack;
     else
       context.type = eContextRegisterStore;
-    context.SetRegisterToRegisterPlusOffset(reg_info_Rt, reg_info_base,
+    context.SetRegisterToRegisterPlusOffset(*reg_info_Rt, *reg_info_base,
                                             postindex ? 0 : offset);
 
-    if (!ReadRegister(&reg_info_Rt, data_Rt))
+    if (!ReadRegister(&(*reg_info_Rt), data_Rt))
       return false;
 
-    if (data_Rt.GetAsMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size,
+    if (data_Rt.GetAsMemoryData(&(*reg_info_Rt), buffer, reg_info_Rt->byte_size,
                                 eByteOrderLittle, error) == 0)
       return false;
 
-    if (!WriteMemory(context, address, buffer, reg_info_Rt.byte_size))
+    if (!WriteMemory(context, address, buffer, reg_info_Rt->byte_size))
       return false;
     break;
 
   case MemOp_LOAD:
     if (n == 31 || n == GetFramePointerRegisterNumber()) // if this store is
                                                          // based off of the sp
                                                          // or fp register
       context.type = eContextPopRegisterOffStack;
     else
       context.type = eContextRegisterLoad;
     context.SetAddress(address);
 
-    if (!ReadMemory(context, address, buffer, reg_info_Rt.byte_size))
+    if (!ReadMemory(context, address, buffer, reg_info_Rt->byte_size))
       return false;
 
-    if (data_Rt.SetFromMemoryData(&reg_info_Rt, buffer, reg_info_Rt.byte_size,
-                                  eByteOrderLittle, error) == 0)
+    if (data_Rt.SetFromMemoryData(&(*reg_info_Rt), buffer,
+                                  reg_info_Rt->byte_size, eByteOrderLittle,
+                                  error) == 0)
       return false;
 
-    if (!WriteRegister(context, &reg_info_Rt, data_Rt))
+    if (!WriteRegister(context, &(*reg_info_Rt), data_Rt))
       return false;
     break;
   default:
     return false;
   }
 
   if (wback) {
     if (postindex)
       address += offset;
 
     if (n == 31)
       context.type = eContextAdjustStackPointer;
     else
       context.type = eContextAdjustBaseRegister;
     context.SetImmediateSigned(offset);
 
-    if (!WriteRegisterUnsigned(context, &reg_info_base, address))
+    if (!WriteRegisterUnsigned(context, &(*reg_info_base), address))
       return false;
   }
   return true;
 }
 
 bool EmulateInstructionARM64::EmulateB(const uint32_t opcode) {
 #if 0
     // ARM64 pseudo code...