================
@@ -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());
+ }
----------------
kuilpd wrote:
Yes, this is in case someone is debugging Swift code and mixing it with a value
from a C++ library. I think this concern was raised at some point in some
discussion, can't recall where exactly.
The code in operator and arithmetic conversion logic expects both operands to
be of the same type system, so we need this check. Not right now, since Swift
doesn't support DIL yet, but once it gets implemented this error will prevent
the rest of the DIL code from breaking. Then we can implement conversion
between type systems, at least for basic types.
https://github.com/llvm/llvm-project/pull/177208
_______________________________________________
lldb-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
