Fix float expressions for PPC64le

[alexandreyy]

Summary

Implemented FCmp and FPExt instructions.

[alexandreyy]

Add SIToFP and UIToFP instructions to handle comparisons between float and char values.

[alexandreyy]

Enabled JIT to handle float expressions for PPC64le.

source/Expression/IRInterpreter.cpp

bool AssignValue(const Value *value, lldb_private::Scalar &scalar,
                    Module &module) {
     lldb::addr_t process_address = ResolveValue(value, module);
 
     if (process_address == LLDB_INVALID_ADDRESS)
       return false;
 
     lldb_private::Scalar cast_scalar;
 
-    if (!AssignToMatchType(cast_scalar, scalar.ULongLong(), value->getType()))
+    if (value->getType()->isDoubleTy())
+      cast_scalar = scalar.Double();
+    else if (!AssignToMatchType(cast_scalar, scalar.ULongLong(), value->getType()))
       return false;
 
     size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType());
 
     lldb_private::DataBufferHeap buf(value_byte_size, 0);
 
     lldb_private::Status get_data_error;
 
for (BasicBlock::iterator ii = bbi->begin(), ie = bbi->end(); ii != ie;
         case CmpInst::ICMP_SGE:
         case CmpInst::ICMP_SLT:
         case CmpInst::ICMP_SLE:
           break;
         }
       } break;
       case Instruction::And:
       case Instruction::AShr:
+      case Instruction::FCmp:
+      case Instruction::FPExt:
       case Instruction::IntToPtr:
       case Instruction::PtrToInt:
       case Instruction::Load:
       case Instruction::LShr:
       case Instruction::Mul:
       case Instruction::Or:
       case Instruction::Ret:
       case Instruction::SDiv:
       case Instruction::SExt:
       case Instruction::Shl:
+      case Instruction::SIToFP:
       case Instruction::SRem:
       case Instruction::Store:
       case Instruction::Sub:
       case Instruction::Trunc:
       case Instruction::UDiv:
       case Instruction::URem:
+      case Instruction::UIToFP:
       case Instruction::Xor:
       case Instruction::ZExt:
         break;
       }
 
       for (int oi = 0, oe = ii->getNumOperands(); oi != oe; ++oi) {
         Value *operand = ii->getOperand(oi);
         Type *operand_type = operand->getType();
case Instruction::ZExt: {
           log->Printf("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::FPExt:
+    case Instruction::SIToFP:
+    case Instruction::UIToFP: {
+       const CastInst *cast_inst = dyn_cast<CastInst>(inst);
+
+       if (!cast_inst) {
+         if (log)
+           log->Printf("Instruction is not a CastInst");
+         error.SetErrorToGenericError();
+         error.SetErrorString(interpreter_internal_error);
+         return false;
+       }
+
+       Value *source = cast_inst->getOperand(0);
+
+       lldb_private::Scalar S;
+
+       if (!frame.EvaluateValue(S, source, module)) {
+         if (log)
+           log->Printf("Couldn't evaluate %s", PrintValue(source).c_str());
+         error.SetErrorToGenericError();
+         error.SetErrorString(bad_value_error);
+         return false;
+       }
+
+       lldb_private::Scalar result;
+       double result_double;
+
+       switch (inst->getOpcode()) {
+       default:
+         break;
+       case Instruction::FPExt:
+         result_double = static_cast<double>(S.Float());
+         break;
+       case Instruction::SIToFP:
+         result_double = static_cast<double>(S.SInt());
+         break;
+       case Instruction::UIToFP:
+         result_double = static_cast<double>(S.UInt());
+         break;
+       }
+
+       lldb_private::Scalar Scalar_Double(result_double);
+       frame.AssignValue(inst, Scalar_Double, module);
+    } break;
     case Instruction::SExt: {
       const CastInst *cast_inst = dyn_cast<CastInst>(inst);
 
       if (!cast_inst) {
         if (log)
           log->Printf(
               "getOpcode() returns %s, but instruction is not a BitCastInst",
               cast_inst->getOpcodeName());
case Instruction::GetElementPtr: {
 
       if (log) {
         log->Printf("Interpreted a GetElementPtrInst");
         log->Printf("  P       : %s",
                     frame.SummarizeValue(pointer_operand).c_str());
         log->Printf("  Poffset : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
+    case Instruction::FCmp:
     case Instruction::ICmp: {
+      CmpInst::Predicate predicate;
+
+      char cmp_type = 0;
+      if (inst->getOpcode() == Instruction::FCmp) {
+        const FCmpInst *fcmp_inst = dyn_cast<FCmpInst>(inst);
+
+        if (fcmp_inst) {
+          predicate = fcmp_inst->getPredicate();
+          cmp_type = 'F';
+        }
+      } else {
         const ICmpInst *icmp_inst = dyn_cast<ICmpInst>(inst);
 
-      if (!icmp_inst) {
-        if (log)
+        if (icmp_inst) {
+          predicate = icmp_inst->getPredicate();
+          cmp_type = 'I';
+        }
+      }
+
+      if (! cmp_type) {
+        if (log) {
           log->Printf(
-              "getOpcode() returns ICmp, but instruction is not an ICmpInst");
+              "getOpcode() returns %cCmp, but instruction is not an %cCmpInst",
+              cmp_type, cmp_type);
+        }
         error.SetErrorToGenericError();
         error.SetErrorString(interpreter_internal_error);
         return false;
       }
 
-      CmpInst::Predicate predicate = icmp_inst->getPredicate();
-
       Value *lhs = inst->getOperand(0);
       Value *rhs = inst->getOperand(1);
 
       lldb_private::Scalar L;
       lldb_private::Scalar R;
 
       if (!frame.EvaluateValue(L, lhs, module)) {
         if (log)
case Instruction::ICmp: {
         return false;
       }
 
       lldb_private::Scalar result;
 
       switch (predicate) {
       default:
         return false;
+      case CmpInst::FCMP_OEQ:
       case CmpInst::ICMP_EQ:
         result = (L == R);
         break;
+      case CmpInst::FCMP_ONE:
       case CmpInst::ICMP_NE:
         result = (L != R);
         break;
+      case CmpInst::FCMP_UGT:
       case CmpInst::ICMP_UGT:
         L.MakeUnsigned();
         R.MakeUnsigned();
         result = (L > R);
         break;
+      case CmpInst::FCMP_UGE:
       case CmpInst::ICMP_UGE:
         L.MakeUnsigned();
         R.MakeUnsigned();
         result = (L >= R);
         break;
+      case CmpInst::FCMP_ULT:
       case CmpInst::ICMP_ULT:
         L.MakeUnsigned();
         R.MakeUnsigned();
         result = (L < R);
         break;
+      case CmpInst::FCMP_ULE:
       case CmpInst::ICMP_ULE:
         L.MakeUnsigned();
         R.MakeUnsigned();
         result = (L <= R);
         break;
+      case CmpInst::FCMP_OGT:
       case CmpInst::ICMP_SGT:
         L.MakeSigned();
         R.MakeSigned();
         result = (L > R);
         break;
+      case CmpInst::FCMP_OGE:
       case CmpInst::ICMP_SGE:
         L.MakeSigned();
         R.MakeSigned();
         result = (L >= R);
         break;
+      case CmpInst::FCMP_OLT:
       case CmpInst::ICMP_SLT:
         L.MakeSigned();
         R.MakeSigned();
         result = (L < R);
         break;
+      case CmpInst::FCMP_OLE:
       case CmpInst::ICMP_SLE:
         L.MakeSigned();
         R.MakeSigned();
         result = (L <= R);
         break;
       }
 
       frame.AssignValue(inst, result, module);
 
       if (log) {
-        log->Printf("Interpreted an ICmpInst");
+        log->Printf("Interpreted an %cCmpInst", cmp_type);
         log->Printf("  L : %s", frame.SummarizeValue(lhs).c_str());
         log->Printf("  R : %s", frame.SummarizeValue(rhs).c_str());
         log->Printf("  = : %s", frame.SummarizeValue(inst).c_str());
       }
     } break;
     case Instruction::IntToPtr: {
       const IntToPtrInst *int_to_ptr_inst = dyn_cast<IntToPtrInst>(inst);