================
@@ -393,6 +474,82 @@ Interpreter::Visit(const UnaryOpNode &node) {
node.GetLocation());
}
+llvm::Expected<lldb::ValueObjectSP>
+Interpreter::EvaluateScalarOp(BinaryOpKind kind, lldb::ValueObjectSP lhs,
+ lldb::ValueObjectSP rhs, CompilerType
result_type,
+ uint32_t location) {
+ Scalar l, r;
+ bool l_resolved = lhs->ResolveValue(l);
+ bool r_resolved = rhs->ResolveValue(r);
+
+ if (!l_resolved || !r_resolved)
+ return llvm::make_error<DILDiagnosticError>(m_expr, "invalid scalar value",
+ location);
+
+ auto value_object = [this, result_type](Scalar scalar) {
+ return ValueObject::CreateValueObjectFromScalar(m_target, scalar,
+ result_type, "result");
+ };
+
+ switch (kind) {
+ case BinaryOpKind::Add:
+ return value_object(l + r);
+ }
+ return llvm::make_error<DILDiagnosticError>(
+ m_expr, "invalid arithmetic operation", location);
+}
+
+llvm::Expected<lldb::ValueObjectSP> Interpreter::EvaluateBinaryAddition(
+ lldb::ValueObjectSP lhs, lldb::ValueObjectSP rhs, uint32_t location) {
+ // Operation '+' works for:
+ // {scalar,unscoped_enum} <-> {scalar,unscoped_enum}
+ // TODO: Pointer arithmetics
+ auto orig_lhs_type = lhs->GetCompilerType();
+ auto orig_rhs_type = rhs->GetCompilerType();
+ auto type_or_err = ArithmeticConversion(lhs, rhs, location);
+ if (!type_or_err)
+ return type_or_err.takeError();
+ CompilerType result_type = *type_or_err;
+
+ if (result_type.IsScalarType())
+ return EvaluateScalarOp(BinaryOpKind::Add, lhs, rhs, result_type,
location);
+
+ std::string errMsg =
+ llvm::formatv("invalid operands to binary expression ('{0}' and '{1}')",
+ orig_lhs_type.GetTypeName(), orig_rhs_type.GetTypeName());
+ return llvm::make_error<DILDiagnosticError>(m_expr, errMsg, location);
+}
+
+llvm::Expected<lldb::ValueObjectSP>
+Interpreter::Visit(const BinaryOpNode &node) {
+ auto lhs_or_err = EvaluateAndDereference(node.GetLHS());
+ if (!lhs_or_err)
+ return lhs_or_err;
+ lldb::ValueObjectSP lhs = *lhs_or_err;
+ auto rhs_or_err = EvaluateAndDereference(node.GetRHS());
+ if (!rhs_or_err)
+ return rhs_or_err;
+ lldb::ValueObjectSP rhs = *rhs_or_err;
+
+ lldb::TypeSystemSP lhs_system =
+ lhs->GetCompilerType().GetTypeSystem().GetSharedPointer();
+ lldb::TypeSystemSP rhs_system =
+ rhs->GetCompilerType().GetTypeSystem().GetSharedPointer();
+ if (lhs_system->GetPluginName() != rhs_system->GetPluginName()) {
+ // TODO: Attempt to convert values to current CU's type system
+ return llvm::make_error<DILDiagnosticError>(
+ m_expr, "operands have different type systems", node.GetLocation());
+ }
----------------
Michael137 wrote:
Not 100% plugin name is reliable to compare typesystem kinds, but I also don't
have a concrete example/use-case where it would break. So seems ok for now
https://github.com/llvm/llvm-project/pull/177208
_______________________________________________
lldb-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
