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/TypeSystem/Clang/TypeSystemClang.h" 11 #include "TestingSupport/Symbol/YAMLModuleTester.h" 12 #include "lldb/Core/Value.h" 13 #include "lldb/Core/dwarf.h" 14 #include "lldb/Symbol/ObjectFile.h" 15 #include "lldb/Utility/StreamString.h" 16 #include "llvm/ADT/StringExtras.h" 17 #include "llvm/Testing/Support/Error.h" 18 #include "gtest/gtest.h" 19 20 using namespace lldb_private; 21 22 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr, 23 lldb::ModuleSP module_sp = {}, 24 DWARFUnit *unit = nullptr) { 25 DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle, 26 /*addr_size*/ 4); 27 Value result; 28 Status status; 29 if (!DWARFExpression::Evaluate( 30 /*exe_ctx*/ nullptr, /*reg_ctx*/ nullptr, module_sp, extractor, unit, 31 lldb::eRegisterKindLLDB, 32 /*initial_value_ptr*/ nullptr, 33 /*object_address_ptr*/ nullptr, result, &status)) 34 return status.ToError(); 35 36 switch (result.GetValueType()) { 37 case Value::eValueTypeScalar: 38 return result.GetScalar(); 39 case Value::eValueTypeHostAddress: { 40 // Convert small buffers to scalars to simplify the tests. 41 DataBufferHeap &buf = result.GetBuffer(); 42 if (buf.GetByteSize() <= 8) { 43 uint64_t val = 0; 44 memcpy(&val, buf.GetBytes(), buf.GetByteSize()); 45 return Scalar(llvm::APInt(buf.GetByteSize()*8, val, false)); 46 } 47 } 48 LLVM_FALLTHROUGH; 49 default: 50 return status.ToError(); 51 } 52 } 53 54 class DWARFExpressionTester : public YAMLModuleTester { 55 public: 56 using YAMLModuleTester::YAMLModuleTester; 57 llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) { 58 return ::Evaluate(expr, m_module_sp, m_dwarf_unit); 59 } 60 }; 61 62 /// Unfortunately Scalar's operator==() is really picky. 63 static Scalar GetScalar(unsigned bits, uint64_t value, bool sign) { 64 Scalar scalar(value); 65 scalar.TruncOrExtendTo(bits, sign); 66 return scalar; 67 } 68 69 TEST(DWARFExpression, DW_OP_pick) { 70 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}), 71 llvm::HasValue(0)); 72 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}), 73 llvm::HasValue(1)); 74 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}), 75 llvm::Failed()); 76 } 77 78 TEST(DWARFExpression, DW_OP_const) { 79 // Extend to address size. 80 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x88}), llvm::HasValue(0x88)); 81 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, 0x88}), 82 llvm::HasValue(0xffffff88)); 83 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x47, 0x88}), 84 llvm::HasValue(0x8847)); 85 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2s, 0x47, 0x88}), 86 llvm::HasValue(0xffff8847)); 87 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4u, 0x44, 0x42, 0x47, 0x88}), 88 llvm::HasValue(0x88474244)); 89 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4s, 0x44, 0x42, 0x47, 0x88}), 90 llvm::HasValue(0x88474244)); 91 92 // Truncate to address size. 93 EXPECT_THAT_EXPECTED( 94 Evaluate({DW_OP_const8u, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}), 95 llvm::HasValue(0x33221100)); 96 EXPECT_THAT_EXPECTED( 97 Evaluate({DW_OP_const8s, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}), 98 llvm::HasValue(0x33221100)); 99 100 // Don't truncate to address size for compatibility with clang (pr48087). 101 EXPECT_THAT_EXPECTED( 102 Evaluate({DW_OP_constu, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}), 103 llvm::HasValue(0x01010101010101)); 104 EXPECT_THAT_EXPECTED( 105 Evaluate({DW_OP_consts, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}), 106 llvm::HasValue(0xffff010101010101)); 107 } 108 109 TEST(DWARFExpression, DW_OP_convert) { 110 /// Auxiliary debug info. 111 const char *yamldata = R"( 112 --- !ELF 113 FileHeader: 114 Class: ELFCLASS64 115 Data: ELFDATA2LSB 116 Type: ET_EXEC 117 Machine: EM_386 118 DWARF: 119 debug_abbrev: 120 - Table: 121 - Code: 0x00000001 122 Tag: DW_TAG_compile_unit 123 Children: DW_CHILDREN_yes 124 Attributes: 125 - Attribute: DW_AT_language 126 Form: DW_FORM_data2 127 - Code: 0x00000002 128 Tag: DW_TAG_base_type 129 Children: DW_CHILDREN_no 130 Attributes: 131 - Attribute: DW_AT_encoding 132 Form: DW_FORM_data1 133 - Attribute: DW_AT_byte_size 134 Form: DW_FORM_data1 135 debug_info: 136 - Version: 4 137 AddrSize: 8 138 Entries: 139 - AbbrCode: 0x00000001 140 Values: 141 - Value: 0x000000000000000C 142 # 0x0000000e: 143 - AbbrCode: 0x00000002 144 Values: 145 - Value: 0x0000000000000007 # DW_ATE_unsigned 146 - Value: 0x0000000000000004 147 # 0x00000011: 148 - AbbrCode: 0x00000002 149 Values: 150 - Value: 0x0000000000000007 # DW_ATE_unsigned 151 - Value: 0x0000000000000008 152 # 0x00000014: 153 - AbbrCode: 0x00000002 154 Values: 155 - Value: 0x0000000000000005 # DW_ATE_signed 156 - Value: 0x0000000000000008 157 # 0x00000017: 158 - AbbrCode: 0x00000002 159 Values: 160 - Value: 0x0000000000000008 # DW_ATE_unsigned_char 161 - Value: 0x0000000000000001 162 # 0x0000001a: 163 - AbbrCode: 0x00000002 164 Values: 165 - Value: 0x0000000000000006 # DW_ATE_signed_char 166 - Value: 0x0000000000000001 167 # 0x0000001d: 168 - AbbrCode: 0x00000002 169 Values: 170 - Value: 0x000000000000000b # DW_ATE_numeric_string 171 - Value: 0x0000000000000001 172 - AbbrCode: 0x00000000 173 )"; 174 uint8_t offs_uint32_t = 0x0000000e; 175 uint8_t offs_uint64_t = 0x00000011; 176 uint8_t offs_sint64_t = 0x00000014; 177 uint8_t offs_uchar = 0x00000017; 178 uint8_t offs_schar = 0x0000001a; 179 180 DWARFExpressionTester t(yamldata); 181 ASSERT_TRUE((bool)t.GetDwarfUnit()); 182 183 // Constant is given as little-endian. 184 bool is_signed = true; 185 bool not_signed = false; 186 187 // 188 // Positive tests. 189 // 190 191 // Leave as is. 192 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, // 193 DW_OP_convert, offs_uint32_t}), 194 llvm::HasValue(GetScalar(64, 0x44332211, not_signed))); 195 196 // Zero-extend to 64 bits. 197 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, // 198 DW_OP_convert, offs_uint64_t}), 199 llvm::HasValue(GetScalar(64, 0x44332211, not_signed))); 200 201 // Sign-extend to 64 bits. 202 EXPECT_THAT_EXPECTED( 203 t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // 204 DW_OP_convert, offs_sint64_t}), 205 llvm::HasValue(GetScalar(64, 0xffffffffffeeddcc, is_signed))); 206 207 // Sign-extend, then truncate. 208 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // 209 DW_OP_convert, offs_sint64_t, // 210 DW_OP_convert, offs_uint32_t}), 211 llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed))); 212 213 // Truncate to default unspecified (pointer-sized) type. 214 EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // 215 DW_OP_convert, offs_sint64_t, // 216 DW_OP_convert, 0x00}), 217 llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed))); 218 219 // Truncate to 8 bits. 220 EXPECT_THAT_EXPECTED( 221 t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert, offs_uchar}), 222 llvm::HasValue(GetScalar(8, 'A', not_signed))); 223 224 // Also truncate to 8 bits. 225 EXPECT_THAT_EXPECTED( 226 t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert, offs_schar}), 227 llvm::HasValue(GetScalar(8, 'A', is_signed))); 228 229 // 230 // Errors. 231 // 232 233 // No Module. 234 EXPECT_THAT_ERROR(Evaluate({DW_OP_const1s, 'X', DW_OP_convert, 0x00}, nullptr, 235 t.GetDwarfUnit()) 236 .takeError(), 237 llvm::Failed()); 238 239 // No DIE. 240 EXPECT_THAT_ERROR( 241 t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x01}).takeError(), 242 llvm::Failed()); 243 244 // Unsupported. 245 EXPECT_THAT_ERROR( 246 t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x1d}).takeError(), 247 llvm::Failed()); 248 } 249 250 TEST(DWARFExpression, DW_OP_stack_value) { 251 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_stack_value}), llvm::Failed()); 252 } 253 254 TEST(DWARFExpression, DW_OP_piece) { 255 EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x11, 0x22, DW_OP_piece, 2, 256 DW_OP_const2u, 0x33, 0x44, DW_OP_piece, 2}), 257 llvm::HasValue(GetScalar(32, 0x44332211, true))); 258 EXPECT_THAT_EXPECTED( 259 Evaluate({DW_OP_piece, 1, DW_OP_const1u, 0xff, DW_OP_piece, 1}), 260 // Note that the "00" should really be "undef", but we can't 261 // represent that yet. 262 llvm::HasValue(GetScalar(16, 0xff00, true))); 263 } 264 265 TEST(DWARFExpression, DW_OP_implicit_value) { 266 unsigned char bytes = 4; 267 268 EXPECT_THAT_EXPECTED( 269 Evaluate({DW_OP_implicit_value, bytes, 0x11, 0x22, 0x33, 0x44}), 270 llvm::HasValue(GetScalar(8 * bytes, 0x44332211, true))); 271 } 272 273 TEST(DWARFExpression, DW_OP_unknown) { 274 EXPECT_THAT_EXPECTED( 275 Evaluate({0xff}), 276 llvm::FailedWithMessage( 277 "Unhandled opcode DW_OP_unknown_ff in DWARFExpression")); 278 } 279