1 //===-- DWARFExpressionTest.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Expression/DWARFExpression.h" 10 #include "Plugins/Platform/Linux/PlatformLinux.h" 11 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 12 #include "TestingSupport/Symbol/YAMLModuleTester.h" 13 #include "lldb/Core/Value.h" 14 #include "lldb/Core/Debugger.h" 15 #include "lldb/Core/dwarf.h" 16 #include "lldb/Host/HostInfo.h" 17 #include "lldb/Symbol/ObjectFile.h" 18 #include "lldb/Utility/Reproducer.h" 19 #include "lldb/Utility/StreamString.h" 20 #include "llvm/ADT/StringExtras.h" 21 #include "llvm/Testing/Support/Error.h" 22 #include "gtest/gtest.h" 23 24 using namespace lldb_private; 25 using namespace lldb_private::dwarf; 26 27 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr, 28 lldb::ModuleSP module_sp = {}, 29 DWARFUnit *unit = nullptr, 30 ExecutionContext *exe_ctx = nullptr) { 31 DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle, 32 /*addr_size*/ 4); 33 Value result; 34 Status status; 35 if (!DWARFExpression::Evaluate(exe_ctx, /*reg_ctx*/ nullptr, module_sp, 36 extractor, unit, lldb::eRegisterKindLLDB, 37 /*initial_value_ptr*/ nullptr, 38 /*object_address_ptr*/ nullptr, result, 39 &status)) 40 return status.ToError(); 41 42 switch (result.GetValueType()) { 43 case Value::ValueType::Scalar: 44 return result.GetScalar(); 45 case Value::ValueType::LoadAddress: 46 return LLDB_INVALID_ADDRESS; 47 case Value::ValueType::HostAddress: { 48 // Convert small buffers to scalars to simplify the tests. 49 DataBufferHeap &buf = result.GetBuffer(); 50 if (buf.GetByteSize() <= 8) { 51 uint64_t val = 0; 52 memcpy(&val, buf.GetBytes(), buf.GetByteSize()); 53 return Scalar(llvm::APInt(buf.GetByteSize()*8, val, false)); 54 } 55 } 56 LLVM_FALLTHROUGH; 57 default: 58 return status.ToError(); 59 } 60 } 61 62 class DWARFExpressionTester : public YAMLModuleTester { 63 public: 64 using YAMLModuleTester::YAMLModuleTester; 65 llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) { 66 return ::Evaluate(expr, m_module_sp, m_dwarf_unit); 67 } 68 }; 69 70 /// Unfortunately Scalar's operator==() is really picky. 71 static Scalar GetScalar(unsigned bits, uint64_t value, bool sign) { 72 Scalar scalar(value); 73 scalar.TruncOrExtendTo(bits, sign); 74 return scalar; 75 } 76 77 /// This is needed for the tests that use a mock process. 78 class DWARFExpressionMockProcessTest : public ::testing::Test { 79 public: 80 void SetUp() override { 81 llvm::cantFail(repro::Reproducer::Initialize(repro::ReproducerMode::Off, {})); 82 FileSystem::Initialize(); 83 HostInfo::Initialize(); 84 platform_linux::PlatformLinux::Initialize(); 85 } 86 void TearDown() override { 87 platform_linux::PlatformLinux::Terminate(); 88 HostInfo::Terminate(); 89 FileSystem::Terminate(); 90 repro::Reproducer::Terminate(); 91 } 92 }; 93 94 TEST(DWARFExpression, DW_OP_pick) { 95 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}), 96 llvm::HasValue(0)); 97 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}), 98 llvm::HasValue(1)); 99 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}), 100 llvm::Failed()); 101 } 102 103 TEST(DWARFExpression, DW_OP_const) { 104 // Extend to address size. 105 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x88}), llvm::HasValue(0x88)); 106 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, 0x88}), 107 llvm::HasValue(0xffffff88)); 108 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x47, 0x88}), 109 llvm::HasValue(0x8847)); 110 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2s, 0x47, 0x88}), 111 llvm::HasValue(0xffff8847)); 112 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4u, 0x44, 0x42, 0x47, 0x88}), 113 llvm::HasValue(0x88474244)); 114 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4s, 0x44, 0x42, 0x47, 0x88}), 115 llvm::HasValue(0x88474244)); 116 117 // Truncate to address size. 118 EXPECT_THAT_EXPECTED( 119 Evaluate({DW_OP_const8u, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}), 120 llvm::HasValue(0x33221100)); 121 EXPECT_THAT_EXPECTED( 122 Evaluate({DW_OP_const8s, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}), 123 llvm::HasValue(0x33221100)); 124 125 // Don't truncate to address size for compatibility with clang (pr48087). 126 EXPECT_THAT_EXPECTED( 127 Evaluate({DW_OP_constu, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}), 128 llvm::HasValue(0x01010101010101)); 129 EXPECT_THAT_EXPECTED( 130 Evaluate({DW_OP_consts, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}), 131 llvm::HasValue(0xffff010101010101)); 132 } 133 134 TEST(DWARFExpression, DW_OP_skip) { 135 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x42, DW_OP_skip, 0x02, 0x00, 136 DW_OP_const1u, 0xff}), 137 llvm::HasValue(0x42)); 138 } 139 140 TEST(DWARFExpression, DW_OP_bra) { 141 EXPECT_THAT_EXPECTED( 142 // clang-format off 143 Evaluate({ 144 DW_OP_const1u, 0x42, // push 0x42 145 DW_OP_const1u, 0x1, // push 0x1 146 DW_OP_bra, 0x02, 0x00, // if 0x1 > 0, then skip 0x0002 opcodes 147 DW_OP_const1u, 0xff, // push 0xff 148 }), 149 // clang-format on 150 llvm::HasValue(0x42)); 151 } 152 153 TEST(DWARFExpression, DW_OP_convert) { 154 /// Auxiliary debug info. 155 const char *yamldata = R"( 156 --- !ELF 157 FileHeader: 158 Class: ELFCLASS64 159 Data: ELFDATA2LSB 160 Type: ET_EXEC 161 Machine: EM_386 162 DWARF: 163 debug_abbrev: 164 - Table: 165 - Code: 0x00000001 166 Tag: DW_TAG_compile_unit 167 Children: DW_CHILDREN_yes 168 Attributes: 169 - Attribute: DW_AT_language 170 Form: DW_FORM_data2 171 - Code: 0x00000002 172 Tag: DW_TAG_base_type 173 Children: DW_CHILDREN_no 174 Attributes: 175 - Attribute: DW_AT_encoding 176 Form: DW_FORM_data1 177 - Attribute: DW_AT_byte_size 178 Form: DW_FORM_data1 179 debug_info: 180 - Version: 4 181 AddrSize: 8 182 Entries: 183 - AbbrCode: 0x00000001 184 Values: 185 - Value: 0x000000000000000C 186 # 0x0000000e: 187 - AbbrCode: 0x00000002 188 Values: 189 - Value: 0x0000000000000007 # DW_ATE_unsigned 190 - Value: 0x0000000000000004 191 # 0x00000011: 192 - AbbrCode: 0x00000002 193 Values: 194 - Value: 0x0000000000000007 # DW_ATE_unsigned 195 - Value: 0x0000000000000008 196 # 0x00000014: 197 - AbbrCode: 0x00000002 198 Values: 199 - Value: 0x0000000000000005 # DW_ATE_signed 200 - Value: 0x0000000000000008 201 # 0x00000017: 202 - AbbrCode: 0x00000002 203 Values: 204 - Value: 0x0000000000000008 # DW_ATE_unsigned_char 205 - Value: 0x0000000000000001 206 # 0x0000001a: 207 - AbbrCode: 0x00000002 208 Values: 209 - Value: 0x0000000000000006 # DW_ATE_signed_char 210 - Value: 0x0000000000000001 211 # 0x0000001d: 212 - AbbrCode: 0x00000002 213 Values: 214 - Value: 0x000000000000000b # DW_ATE_numeric_string 215 - Value: 0x0000000000000001 216 - AbbrCode: 0x00000000 217 )"; 218 uint8_t offs_uint32_t = 0x0000000e; 219 uint8_t offs_uint64_t = 0x00000011; 220 uint8_t offs_sint64_t = 0x00000014; 221 uint8_t offs_uchar = 0x00000017; 222 uint8_t offs_schar = 0x0000001a; 223 224 DWARFExpressionTester t(yamldata); 225 ASSERT_TRUE((bool)t.GetDwarfUnit()); 226 227 // Constant is given as little-endian. 228 bool is_signed = true; 229 bool not_signed = false; 230 231 // 232 // Positive tests. 233 // 234 235 // Leave as is. 236 EXPECT_THAT_EXPECTED( 237 t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, // 238 DW_OP_convert, offs_uint32_t, DW_OP_stack_value}), 239 llvm::HasValue(GetScalar(64, 0x44332211, not_signed))); 240 241 // Zero-extend to 64 bits. 242 EXPECT_THAT_EXPECTED( 243 t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, // 244 DW_OP_convert, offs_uint64_t, DW_OP_stack_value}), 245 llvm::HasValue(GetScalar(64, 0x44332211, not_signed))); 246 247 // Sign-extend to 64 bits. 248 EXPECT_THAT_EXPECTED( 249 t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // 250 DW_OP_convert, offs_sint64_t, DW_OP_stack_value}), 251 llvm::HasValue(GetScalar(64, 0xffffffffffeeddcc, is_signed))); 252 253 // Sign-extend, then truncate. 254 EXPECT_THAT_EXPECTED( 255 t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // 256 DW_OP_convert, offs_sint64_t, // 257 DW_OP_convert, offs_uint32_t, DW_OP_stack_value}), 258 llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed))); 259 260 // Truncate to default unspecified (pointer-sized) type. 261 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // 262 DW_OP_convert, offs_sint64_t, // 263 DW_OP_convert, 0x00, DW_OP_stack_value}), 264 llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed))); 265 266 // Truncate to 8 bits. 267 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert, 268 offs_uchar, DW_OP_stack_value}), 269 llvm::HasValue(GetScalar(8, 'A', not_signed))); 270 271 // Also truncate to 8 bits. 272 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert, 273 offs_schar, DW_OP_stack_value}), 274 llvm::HasValue(GetScalar(8, 'A', is_signed))); 275 276 // 277 // Errors. 278 // 279 280 // No Module. 281 EXPECT_THAT_ERROR(Evaluate({DW_OP_const1s, 'X', DW_OP_convert, 0x00}, nullptr, 282 t.GetDwarfUnit()) 283 .takeError(), 284 llvm::Failed()); 285 286 // No DIE. 287 EXPECT_THAT_ERROR( 288 t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x01}).takeError(), 289 llvm::Failed()); 290 291 // Unsupported. 292 EXPECT_THAT_ERROR( 293 t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x1d}).takeError(), 294 llvm::Failed()); 295 } 296 297 TEST(DWARFExpression, DW_OP_stack_value) { 298 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_stack_value}), llvm::Failed()); 299 } 300 301 TEST(DWARFExpression, DW_OP_piece) { 302 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x11, 0x22, DW_OP_piece, 2, 303 DW_OP_const2u, 0x33, 0x44, DW_OP_piece, 2}), 304 llvm::HasValue(GetScalar(32, 0x44332211, true))); 305 EXPECT_THAT_EXPECTED( 306 Evaluate({DW_OP_piece, 1, DW_OP_const1u, 0xff, DW_OP_piece, 1}), 307 // Note that the "00" should really be "undef", but we can't 308 // represent that yet. 309 llvm::HasValue(GetScalar(16, 0xff00, true))); 310 } 311 312 TEST(DWARFExpression, DW_OP_implicit_value) { 313 unsigned char bytes = 4; 314 315 EXPECT_THAT_EXPECTED( 316 Evaluate({DW_OP_implicit_value, bytes, 0x11, 0x22, 0x33, 0x44}), 317 llvm::HasValue(GetScalar(8 * bytes, 0x44332211, true))); 318 } 319 320 TEST(DWARFExpression, DW_OP_unknown) { 321 EXPECT_THAT_EXPECTED( 322 Evaluate({0xff}), 323 llvm::FailedWithMessage( 324 "Unhandled opcode DW_OP_unknown_ff in DWARFExpression")); 325 } 326 327 TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) { 328 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit0, DW_OP_deref}), llvm::Failed()); 329 330 struct MockProcess : Process { 331 using Process::Process; 332 llvm::StringRef GetPluginName() override { return "mock process"; } 333 bool CanDebug(lldb::TargetSP target, 334 bool plugin_specified_by_name) override { 335 return false; 336 }; 337 Status DoDestroy() override { return {}; } 338 void RefreshStateAfterStop() override {} 339 bool DoUpdateThreadList(ThreadList &old_thread_list, 340 ThreadList &new_thread_list) override { 341 return false; 342 }; 343 size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, 344 Status &error) override { 345 for (size_t i = 0; i < size; ++i) 346 ((char *)buf)[i] = (vm_addr + i) & 0xff; 347 error.Clear(); 348 return size; 349 } 350 }; 351 352 // Set up a mock process. 353 ArchSpec arch("i386-pc-linux"); 354 Platform::SetHostPlatform( 355 platform_linux::PlatformLinux::CreateInstance(true, &arch)); 356 lldb::DebuggerSP debugger_sp = Debugger::CreateInstance(); 357 ASSERT_TRUE(debugger_sp); 358 lldb::TargetSP target_sp; 359 lldb::PlatformSP platform_sp; 360 debugger_sp->GetTargetList().CreateTarget( 361 *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp); 362 ASSERT_TRUE(target_sp); 363 ASSERT_TRUE(target_sp->GetArchitecture().IsValid()); 364 ASSERT_TRUE(platform_sp); 365 lldb::ListenerSP listener_sp(Listener::MakeListener("dummy")); 366 lldb::ProcessSP process_sp = 367 std::make_shared<MockProcess>(target_sp, listener_sp); 368 ASSERT_TRUE(process_sp); 369 370 ExecutionContext exe_ctx(process_sp); 371 // Implicit location: *0x4. 372 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, 373 {}, {}, &exe_ctx), 374 llvm::HasValue(GetScalar(32, 0x07060504, false))); 375 // Memory location: *(*0x4). 376 // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses. 377 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref}, {}, {}, &exe_ctx), 378 llvm::HasValue(Scalar(LLDB_INVALID_ADDRESS))); 379 // Memory location: *0x4. 380 // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses. 381 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4}, {}, {}, &exe_ctx), 382 llvm::HasValue(Scalar(4))); 383 // Implicit location: *0x4. 384 // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses. 385 EXPECT_THAT_EXPECTED( 386 Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, {}, {}, &exe_ctx), 387 llvm::HasValue(GetScalar(32, 0x07060504, false))); 388 } 389