================
@@ -632,6 +632,461 @@ TEST(DWARFExpression, DW_OP_unknown) {
"unhandled opcode DW_OP_unknown_ff in DWARFExpression"));
}
+TEST(DWARFExpression, DW_OP_addr) {
+ EXPECT_THAT_EXPECTED(
+ Evaluate({DW_OP_addr, 0x10, 0x20, 0x30, 0x40, DW_OP_stack_value}),
+ ExpectScalar(uint32_t{0x40302010}));
+}
+
+TEST(DWARFExpression, DW_OP_nop) {
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit5, DW_OP_nop}), ExpectScalar(5));
+}
+
+TEST(DWARFExpression, DW_OP_neg) {
+ // neg interprets the operand as signed.
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit5, DW_OP_neg}),
+ ExpectScalar(static_cast<int32_t>(-5)));
+}
+
+TEST(DWARFExpression, DW_OP_abs) {
+ EXPECT_THAT_EXPECTED(
+ Evaluate({DW_OP_const1s, static_cast<uint8_t>(-5), DW_OP_abs}),
+ ExpectScalar(5));
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit5, DW_OP_abs}), ExpectScalar(5));
+}
+
+TEST(DWARFExpression, DW_OP_div_int_min_by_neg_one) {
+ // INT32_MIN / -1 is C++ UB; the evaluator must not crash.
+ auto result = Evaluate({DW_OP_const4s, 0x00, 0x00, 0x00, 0x80, DW_OP_const1s,
+ static_cast<uint8_t>(-1), DW_OP_div});
+ if (!result)
+ llvm::consumeError(result.takeError());
+ SUCCEED();
+}
+
+TEST(DWARFExpression, DW_OP_div) {
+ // Signed division: -10 / 3 = -3 (truncation toward zero).
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, static_cast<uint8_t>(-10),
+ DW_OP_const1s, 3, DW_OP_div}),
+ ExpectScalar(static_cast<int32_t>(-3)));
+}
+
+TEST(DWARFExpression, DW_OP_mod) {
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, static_cast<uint8_t>(-7),
+ DW_OP_const1s, 3, DW_OP_mod}),
+ ExpectScalar(static_cast<int32_t>(-1)));
+}
+
+TEST(DWARFExpression, DW_OP_minus) {
+ // Generic arithmetic wraps modulo address-size: 0 - 1 = 0xFFFFFFFF.
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit0, DW_OP_lit1, DW_OP_minus}),
+ ExpectScalar(uint32_t{0xFFFFFFFF}));
+}
+
+TEST(DWARFExpression, DW_OP_plus) {
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit5, DW_OP_lit3, DW_OP_plus}),
+ ExpectScalar(8));
+}
+
+TEST(DWARFExpression, DW_OP_mul) {
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit5, DW_OP_lit3, DW_OP_mul}),
+ ExpectScalar(15));
+}
+
+TEST(DWARFExpression, DW_OP_plus_uconst) {
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, static_cast<uint8_t>(-10),
+ DW_OP_plus_uconst, 5}),
+ ExpectScalar(static_cast<int32_t>(-5)));
+}
+
+TEST(DWARFExpression, DW_OP_and) {
+ EXPECT_THAT_EXPECTED(
+ Evaluate({DW_OP_const1u, 0x0F, DW_OP_const1u, 0x33, DW_OP_and}),
+ ExpectScalar(0x03));
+}
+
+TEST(DWARFExpression, DW_OP_or) {
+ EXPECT_THAT_EXPECTED(
+ Evaluate({DW_OP_const1u, 0x0F, DW_OP_const1u, 0x30, DW_OP_or}),
+ ExpectScalar(0x3F));
+}
+
+TEST(DWARFExpression, DW_OP_xor) {
+ EXPECT_THAT_EXPECTED(
+ Evaluate({DW_OP_const1u, 0x0F, DW_OP_const1u, 0x33, DW_OP_xor}),
+ ExpectScalar(0x3C));
+}
+
+TEST(DWARFExpression, DW_OP_not) {
+ EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit0, DW_OP_not}),
+ ExpectScalar(uint32_t{0xFFFFFFFF}));
+}
+
+TEST(DWARFExpression, DW_OP_lt) {
+ EXPECT_THAT_EXPECTED(
+ Evaluate({DW_OP_const1s, static_cast<uint8_t>(-1), DW_OP_lit0,
DW_OP_lt}),
+ ExpectScalar(1));
+}
----------------
s-barannikov wrote:
Test that swapping the operands inverses the result?
Ideally all of the relative comparisons should test at least three cases: a <
b, a == b, a > b.
https://github.com/llvm/llvm-project/pull/196218
_______________________________________________
lldb-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
