[lldb] Don't defend against internal LLVM errors in IRInterpreter

[teemperor]

Summary

Whenever we cast an LLVM instruction to one of its subclasses, we do a double check if the RTTI
enum value actually allows us to cast the class. I don't see a way this can ever happen as even when
LLVM's RTTI system has some corrupt internal state (which we probably should not test in the first
place) we just reuse LLVM RTTI to do the second check.

This also means that if we ever make an actual programming error in this function (e.g., have a enum
value and then cast it to a different subclass), we just silently fall back to the JIT in our tests.

We also can't test this code in any reasonable way.

This removes the checks and uses llvm::cast instead which will raise a fatal error when casting fails.

[labath]

Yes, I remember being baffled by this in the past...

lldb/source/Expression/IRInterpreter.cpp

case Instruction::Xor: {
       if (log) {
         LLDB_LOGF(log, "Interpreted a %s", inst->getOpcodeName());
         LLDB_LOGF(log, "  L : %s", frame.SummarizeValue(lhs).c_str());
         LLDB_LOGF(log, "  R : %s", frame.SummarizeValue(rhs).c_str());
         LLDB_LOGF(log, "  = : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::Alloca: {
-      const AllocaInst *alloca_inst = dyn_cast<AllocaInst>(inst);
-
-      if (!alloca_inst) {
-        LLDB_LOGF(log, "getOpcode() returns Alloca, but instruction is not an "
-                       "AllocaInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const AllocaInst *alloca_inst = cast<AllocaInst>(inst);
 
       if (alloca_inst->isArrayAllocation()) {
         LLDB_LOGF(log,
                   "AllocaInsts are not handled if isArrayAllocation() is true");
         error.SetErrorToGenericError();
         error.SetErrorString(unsupported_opcode_error);
         return false;
       }
case Instruction::Alloca: {
       if (log) {
         LLDB_LOGF(log, "Interpreted an AllocaInst");
         LLDB_LOGF(log, "  R : 0x%" PRIx64, R);
         LLDB_LOGF(log, "  P : 0x%" PRIx64, P);
       }
     } break;
     case Instruction::BitCast:
     case Instruction::ZExt: {
-      const CastInst *cast_inst = dyn_cast<CastInst>(inst);
-
-      if (!cast_inst) {
-        LLDB_LOGF(
-            log, "getOpcode() returns %s, but instruction is not a BitCastInst",
-            cast_inst->getOpcodeName());
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const CastInst *cast_inst = cast<CastInst>(inst);
 
       Value *source = cast_inst->getOperand(0);
 
       lldb_private::Scalar S;
 
       if (!frame.EvaluateValue(S, source, module)) {
         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
         error.SetErrorToGenericError();
         error.SetErrorString(bad_value_error);
         return false;
       }
 
       frame.AssignValue(inst, S, module);
     } break;
     case Instruction::SExt: {
-      const CastInst *cast_inst = dyn_cast<CastInst>(inst);
-
-      if (!cast_inst) {
-        LLDB_LOGF(
-            log, "getOpcode() returns %s, but instruction is not a BitCastInst",
-            cast_inst->getOpcodeName());
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const CastInst *cast_inst = cast<CastInst>(inst);
 
       Value *source = cast_inst->getOperand(0);
 
       lldb_private::Scalar S;
 
       if (!frame.EvaluateValue(S, source, module)) {
         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
         error.SetErrorToGenericError();
         error.SetErrorString(bad_value_error);
         return false;
       }
 
       S.MakeSigned();
 
       lldb_private::Scalar S_signextend(S.SLongLong());
 
       frame.AssignValue(inst, S_signextend, module);
     } break;
     case Instruction::Br: {
-      const BranchInst *br_inst = dyn_cast<BranchInst>(inst);
-
-      if (!br_inst) {
-        LLDB_LOGF(
-            log, "getOpcode() returns Br, but instruction is not a BranchInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const BranchInst *br_inst = cast<BranchInst>(inst);
 
       if (br_inst->isConditional()) {
         Value *condition = br_inst->getCondition();
 
         lldb_private::Scalar C;
 
         if (!frame.EvaluateValue(C, condition, module)) {
           LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(condition).c_str());
case Instruction::Br: {
 
         if (log) {
           LLDB_LOGF(log, "Interpreted a BrInst with no condition");
         }
       }
     }
       continue;
     case Instruction::PHI: {
-      const PHINode *phi_inst = dyn_cast<PHINode>(inst);
-
-      if (!phi_inst) {
-        LLDB_LOGF(log,
-                  "getOpcode() returns PHI, but instruction is not a PHINode");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const PHINode *phi_inst = cast<PHINode>(inst);
       if (!frame.m_prev_bb) {
         LLDB_LOGF(log,
                   "Encountered PHI node without having jumped from another "
                   "basic block");
         error.SetErrorToGenericError();
         error.SetErrorString(interpreter_internal_error);
         return false;
       }
case Instruction::PHI: {
 
       if (log) {
         LLDB_LOGF(log, "Interpreted a %s", inst->getOpcodeName());
         LLDB_LOGF(log, "  Incoming value : %s",
                   frame.SummarizeValue(value).c_str());
       }
     } break;
     case Instruction::GetElementPtr: {
-      const GetElementPtrInst *gep_inst = dyn_cast<GetElementPtrInst>(inst);
-
-      if (!gep_inst) {
-        LLDB_LOGF(log, "getOpcode() returns GetElementPtr, but instruction is "
-                       "not a GetElementPtrInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const GetElementPtrInst *gep_inst = cast<GetElementPtrInst>(inst);
 
       const Value *pointer_operand = gep_inst->getPointerOperand();
       Type *src_elem_ty = gep_inst->getSourceElementType();
 
       lldb_private::Scalar P;
 
       if (!frame.EvaluateValue(P, pointer_operand, module)) {
         LLDB_LOGF(log, "Couldn't evaluate %s",
case Instruction::GetElementPtr: {
       if (log) {
         LLDB_LOGF(log, "Interpreted a GetElementPtrInst");
         LLDB_LOGF(log, "  P       : %s",
                   frame.SummarizeValue(pointer_operand).c_str());
         LLDB_LOGF(log, "  Poffset : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::ICmp: {
-      const ICmpInst *icmp_inst = dyn_cast<ICmpInst>(inst);
-
-      if (!icmp_inst) {
-        LLDB_LOGF(
-            log,
-            "getOpcode() returns ICmp, but instruction is not an ICmpInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const ICmpInst *icmp_inst = cast<ICmpInst>(inst);
 
       CmpInst::Predicate predicate = icmp_inst->getPredicate();
 
       Value *lhs = inst->getOperand(0);
       Value *rhs = inst->getOperand(1);
 
       lldb_private::Scalar L;
       lldb_private::Scalar R;
case Instruction::ICmp: {
       if (log) {
         LLDB_LOGF(log, "Interpreted an ICmpInst");
         LLDB_LOGF(log, "  L : %s", frame.SummarizeValue(lhs).c_str());
         LLDB_LOGF(log, "  R : %s", frame.SummarizeValue(rhs).c_str());
         LLDB_LOGF(log, "  = : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::IntToPtr: {
-      const IntToPtrInst *int_to_ptr_inst = dyn_cast<IntToPtrInst>(inst);
-
-      if (!int_to_ptr_inst) {
-        LLDB_LOGF(log,
-                  "getOpcode() returns IntToPtr, but instruction is not an "
-                  "IntToPtrInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const IntToPtrInst *int_to_ptr_inst = cast<IntToPtrInst>(inst);
 
       Value *src_operand = int_to_ptr_inst->getOperand(0);
 
       lldb_private::Scalar I;
 
       if (!frame.EvaluateValue(I, src_operand, module)) {
         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
         error.SetErrorToGenericError();
         error.SetErrorString(bad_value_error);
         return false;
       }
 
       frame.AssignValue(inst, I, module);
 
       if (log) {
         LLDB_LOGF(log, "Interpreted an IntToPtr");
         LLDB_LOGF(log, "  Src : %s", frame.SummarizeValue(src_operand).c_str());
         LLDB_LOGF(log, "  =   : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::PtrToInt: {
-      const PtrToIntInst *ptr_to_int_inst = dyn_cast<PtrToIntInst>(inst);
-
-      if (!ptr_to_int_inst) {
-        LLDB_LOGF(log,
-                  "getOpcode() returns PtrToInt, but instruction is not an "
-                  "PtrToIntInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const PtrToIntInst *ptr_to_int_inst = cast<PtrToIntInst>(inst);
 
       Value *src_operand = ptr_to_int_inst->getOperand(0);
 
       lldb_private::Scalar I;
 
       if (!frame.EvaluateValue(I, src_operand, module)) {
         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
         error.SetErrorToGenericError();
         error.SetErrorString(bad_value_error);
         return false;
       }
 
       frame.AssignValue(inst, I, module);
 
       if (log) {
         LLDB_LOGF(log, "Interpreted a PtrToInt");
         LLDB_LOGF(log, "  Src : %s", frame.SummarizeValue(src_operand).c_str());
         LLDB_LOGF(log, "  =   : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::Trunc: {
-      const TruncInst *trunc_inst = dyn_cast<TruncInst>(inst);
-
-      if (!trunc_inst) {
-        LLDB_LOGF(
-            log,
-            "getOpcode() returns Trunc, but instruction is not a TruncInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const TruncInst *trunc_inst = cast<TruncInst>(inst);
 
       Value *src_operand = trunc_inst->getOperand(0);
 
       lldb_private::Scalar I;
 
       if (!frame.EvaluateValue(I, src_operand, module)) {
         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(src_operand).c_str());
         error.SetErrorToGenericError();
         error.SetErrorString(bad_value_error);
         return false;
       }
 
       frame.AssignValue(inst, I, module);
 
       if (log) {
         LLDB_LOGF(log, "Interpreted a Trunc");
         LLDB_LOGF(log, "  Src : %s", frame.SummarizeValue(src_operand).c_str());
         LLDB_LOGF(log, "  =   : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::Load: {
-      const LoadInst *load_inst = dyn_cast<LoadInst>(inst);
-
-      if (!load_inst) {
-        LLDB_LOGF(
-            log, "getOpcode() returns Load, but instruction is not a LoadInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const LoadInst *load_inst = cast<LoadInst>(inst);
 
       // The semantics of Load are:
       //   Create a region D that will contain the loaded data
       //   Resolve the region P containing a pointer
       //   Dereference P to get the region R that the data should be loaded from
       //   Transfer a unit of type type(D) from R to D
 
       const Value *pointer_operand = load_inst->getPointerOperand();
case Instruction::Load: {
         LLDB_LOGF(log, "  R : 0x%" PRIx64, R);
         LLDB_LOGF(log, "  D : 0x%" PRIx64, D);
       }
     } break;
     case Instruction::Ret: {
       return true;
     }
     case Instruction::Store: {
-      const StoreInst *store_inst = dyn_cast<StoreInst>(inst);
-
-      if (!store_inst) {
-        LLDB_LOGF(
-            log,
-            "getOpcode() returns Store, but instruction is not a StoreInst");
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const StoreInst *store_inst = cast<StoreInst>(inst);
 
       // The semantics of Store are:
       //   Resolve the region D containing the data to be stored
       //   Resolve the region P containing a pointer
       //   Dereference P to get the region R that the data should be stored in
       //   Transfer a unit of type type(D) from D to R
 
       const Value *value_operand = store_inst->getValueOperand();
case Instruction::Store: {
       if (log) {
         LLDB_LOGF(log, "Interpreted a StoreInst");
         LLDB_LOGF(log, "  D : 0x%" PRIx64, D);
         LLDB_LOGF(log, "  P : 0x%" PRIx64, P);
         LLDB_LOGF(log, "  R : 0x%" PRIx64, R);
       }
     } break;
     case Instruction::Call: {
-      const CallInst *call_inst = dyn_cast<CallInst>(inst);
-
-      if (!call_inst) {
-        LLDB_LOGF(log,
-                  "getOpcode() returns %s, but instruction is not a CallInst",
-                  inst->getOpcodeName());
-        error.SetErrorToGenericError();
-        error.SetErrorString(interpreter_internal_error);
-        return false;
-      }
+      const CallInst *call_inst = cast<CallInst>(inst);
 
       if (CanIgnoreCall(call_inst))
         break;
 
       // Get the return type
       llvm::Type *returnType = call_inst->getType();
       if (returnType == nullptr) {
         error.SetErrorToGenericError();