947 const Value *object_address_ptr) {
950 return llvm::createStringError(
951 "no location, value may have been optimized out");
964 if (reg_ctx ==
nullptr && frame)
967 if (initial_value_ptr)
968 stack.push_back(*initial_value_ptr);
975 uint64_t op_piece_offset = 0;
983 auto to_generic = [&](
auto v) {
986 bool is_signed = std::is_signed<
decltype(v)>::value;
995 LocationDescriptionKind dwarf4_location_description_kind =
Memory;
999 const uint8_t op = opcodes.
GetU8(&offset);
1002 size_t count = stack.size();
1003 LLDB_LOGF(log,
"Stack before operation has %" PRIu64
" values:",
1005 for (
size_t i = 0; i < count; ++i) {
1007 new_value.
Printf(
"[%" PRIu64
"]", (uint64_t)i);
1008 stack[i].Dump(&new_value);
1011 LLDB_LOGF(log,
"0x%8.8" PRIx64
": %s", op_offset,
1015 if (std::optional<unsigned> arity =
1016 llvm::dwarf::OperationArity(
static_cast<LocationAtom
>(op))) {
1017 if (stack.size() < *arity)
1018 return llvm::createStringError(
1019 "%s needs at least %d stack entries (stack has %d entries)",
1082 if (llvm::Error err =
1099 case DW_OP_deref_size: {
1100 if (stack.empty()) {
1101 return llvm::createStringError(
1102 "expression stack empty for DW_OP_deref_size");
1104 uint8_t size = opcodes.
GetU8(&offset);
1106 return llvm::createStringError(
1107 "Invalid address size for DW_OP_deref_size: %d\n", size);
1110 switch (value_type) {
1112 void *src = (
void *)stack.back().GetScalar().ULongLong();
1114 ::memcpy(&ptr, src,
sizeof(
void *));
1127 ptr = ptr & 0xffffff;
1130 ptr = ptr & 0xffffffff;
1137 ptr = (intptr_t)ptr & 0xffffffffffULL;
1140 ptr = (intptr_t)ptr & 0xffffffffffffULL;
1143 ptr = (intptr_t)ptr & 0xffffffffffffffULL;
1148 stack.back().GetScalar() = ptr;
1149 stack.back().ClearContext();
1156 exe_ctx, module_sp,
"DW_OP_deref_size", file_addr, so_addr,
1159 if (!maybe_load_addr)
1160 return maybe_load_addr.takeError();
1162 addr_t load_addr = *maybe_load_addr;
1165 uint8_t addr_bytes[8];
1171 ObjectFile *objfile = module_sp->GetObjectFile();
1175 stack.back().ClearContext();
1178 return llvm::createStringError(
1179 "Failed to dereference pointer for DW_OP_deref_size: "
1184 stack.back().GetScalar() = load_addr;
1200 stack.back().GetScalar() =
1203 stack.back().ClearContext();
1205 return llvm::createStringError(
1206 "Failed to dereference pointer from 0x%" PRIx64
1207 " for DW_OP_deref: %s\n",
1208 pointer_addr,
error.AsCString());
1212 return llvm::createStringError(
"NULL process for DW_OP_deref_size");
1215 return llvm::createStringError(
1216 "NULL execution context for DW_OP_deref_size");
1222 return llvm::createStringError(
"invalid value for DW_OP_deref_size");
1242 case DW_OP_xderef_size:
1243 return llvm::createStringError(
"unimplemented opcode: DW_OP_xderef_size");
1255 return llvm::createStringError(
"unimplemented opcode: DW_OP_xderef");
1271 stack.push_back(to_generic(opcodes.
GetU8(&offset)));
1274 stack.push_back(to_generic((int8_t)opcodes.
GetU8(&offset)));
1277 stack.push_back(to_generic(opcodes.
GetU16(&offset)));
1280 stack.push_back(to_generic((int16_t)opcodes.
GetU16(&offset)));
1283 stack.push_back(to_generic(opcodes.
GetU32(&offset)));
1286 stack.push_back(to_generic((int32_t)opcodes.
GetU32(&offset)));
1289 stack.push_back(to_generic(opcodes.
GetU64(&offset)));
1292 stack.push_back(to_generic((int64_t)opcodes.
GetU64(&offset)));
1307 if (stack.empty()) {
1308 return llvm::createStringError(
"expression stack empty for DW_OP_dup");
1310 stack.push_back(stack.back());
1317 if (stack.empty()) {
1318 return llvm::createStringError(
"expression stack empty for DW_OP_drop");
1328 stack.push_back(stack[stack.size() - 2]);
1336 uint8_t pick_idx = opcodes.
GetU8(&offset);
1337 if (pick_idx < stack.size())
1338 stack.push_back(stack[stack.size() - 1 - pick_idx]);
1340 return llvm::createStringError(
1341 "Index %u out of range for DW_OP_pick.\n", pick_idx);
1352 stack.back() = stack[stack.size() - 2];
1353 stack[stack.size() - 2] = tmp;
1363 size_t last_idx = stack.size() - 1;
1364 Value old_top = stack[last_idx];
1365 stack[last_idx] = stack[last_idx - 1];
1366 stack[last_idx - 1] = stack[last_idx - 2];
1367 stack[last_idx - 2] = old_top;
1376 if (!stack.back().ResolveValue(exe_ctx).AbsoluteValue()) {
1377 return llvm::createStringError(
1378 "failed to take the absolute value of the first stack item");
1389 stack.back().ResolveValue(exe_ctx) =
1390 stack.back().ResolveValue(exe_ctx) & tmp.
ResolveValue(exe_ctx);
1401 return llvm::createStringError(
"divide by zero");
1404 Scalar divisor, dividend;
1406 dividend = stack.back().ResolveValue(exe_ctx);
1409 stack.back() = dividend / divisor;
1411 if (!stack.back().ResolveValue(exe_ctx).IsValid())
1412 return llvm::createStringError(
"divide failed");
1422 stack.back().ResolveValue(exe_ctx) =
1423 stack.back().ResolveValue(exe_ctx) - tmp.
ResolveValue(exe_ctx);
1434 stack.back().ResolveValue(exe_ctx) =
1435 stack.back().ResolveValue(exe_ctx) % tmp.
ResolveValue(exe_ctx);
1445 stack.back().ResolveValue(exe_ctx) =
1446 stack.back().ResolveValue(exe_ctx) * tmp.
ResolveValue(exe_ctx);
1453 if (!stack.back().ResolveValue(exe_ctx).UnaryNegate())
1454 return llvm::createStringError(
"unary negate failed");
1462 if (!stack.back().ResolveValue(exe_ctx).OnesComplement())
1463 return llvm::createStringError(
"logical NOT failed");
1473 stack.back().ResolveValue(exe_ctx) =
1474 stack.back().ResolveValue(exe_ctx) | tmp.
ResolveValue(exe_ctx);
1484 stack.back().GetScalar() += tmp.
GetScalar();
1491 case DW_OP_plus_uconst: {
1492 const uint64_t uconst_value = opcodes.
GetULEB128(&offset);
1494 stack.back().GetScalar() += uconst_value;
1495 if (!stack.back().GetScalar().IsValid())
1496 return llvm::createStringError(
"DW_OP_plus_uconst failed");
1507 stack.back().ResolveValue(exe_ctx) <<= tmp.
ResolveValue(exe_ctx);
1518 if (!stack.back().ResolveValue(exe_ctx).ShiftRightLogical(
1520 return llvm::createStringError(
"DW_OP_shr failed");
1532 stack.back().ResolveValue(exe_ctx) >>= tmp.
ResolveValue(exe_ctx);
1542 stack.back().ResolveValue(exe_ctx) =
1543 stack.back().ResolveValue(exe_ctx) ^ tmp.
ResolveValue(exe_ctx);
1553 int16_t skip_offset = (int16_t)opcodes.
GetU16(&offset);
1559 offset = new_offset;
1561 return llvm::createStringError(llvm::formatv(
1562 "Invalid opcode offset in DW_OP_skip: {0}+({1}) > {2}", offset,
1577 int16_t bra_offset = (int16_t)opcodes.
GetU16(&offset);
1585 offset = new_offset;
1587 return llvm::createStringError(llvm::formatv(
1588 "Invalid opcode offset in DW_OP_bra: {0}+({1}) > {2}", offset,
1604 stack.back().ResolveValue(exe_ctx) =
1605 stack.back().ResolveValue(exe_ctx) == tmp.
ResolveValue(exe_ctx);
1618 stack.back().ResolveValue(exe_ctx) =
1619 stack.back().ResolveValue(exe_ctx) >= tmp.
ResolveValue(exe_ctx);
1632 stack.back().ResolveValue(exe_ctx) =
1633 stack.back().ResolveValue(exe_ctx) > tmp.
ResolveValue(exe_ctx);
1646 stack.back().ResolveValue(exe_ctx) =
1647 stack.back().ResolveValue(exe_ctx) <= tmp.
ResolveValue(exe_ctx);
1660 stack.back().ResolveValue(exe_ctx) =
1661 stack.back().ResolveValue(exe_ctx) < tmp.
ResolveValue(exe_ctx);
1674 stack.back().ResolveValue(exe_ctx) =
1675 stack.back().ResolveValue(exe_ctx) != tmp.
ResolveValue(exe_ctx);
1715 stack.push_back(to_generic(op - DW_OP_lit0));
1753 dwarf4_location_description_kind = Register;
1754 reg_num = op - DW_OP_reg0;
1756 if (llvm::Error err =
1759 stack.push_back(tmp);
1766 dwarf4_location_description_kind = Register;
1769 if (llvm::Error err =
1772 stack.push_back(tmp);
1811 case DW_OP_breg31: {
1812 reg_num = op - DW_OP_breg0;
1813 if (llvm::Error err =
1817 int64_t breg_offset = opcodes.
GetSLEB128(&offset);
1820 stack.push_back(tmp);
1831 if (llvm::Error err =
1835 int64_t breg_offset = opcodes.
GetSLEB128(&offset);
1838 stack.push_back(tmp);
1848 int64_t fbreg_offset = opcodes.
GetSLEB128(&offset);
1849 value += fbreg_offset;
1850 stack.push_back(value);
1853 return llvm::createStringError(
1854 "invalid stack frame in context for DW_OP_fbreg opcode");
1857 return llvm::createStringError(
1858 "NULL execution context for DW_OP_fbreg");
1884 LocationDescriptionKind piece_locdesc = dwarf4_location_description_kind;
1886 dwarf4_location_description_kind =
Memory;
1888 const uint64_t piece_byte_size = opcodes.
GetULEB128(&offset);
1890 if (piece_byte_size > 0) {
1893 if (stack.empty()) {
1894 UpdateValueTypeFromLocationDescription(
1895 log, dwarf_cu, LocationDescriptionKind::Empty);
1909 Value curr_piece_source_value(stack.back());
1911 UpdateValueTypeFromLocationDescription(log, dwarf_cu, piece_locdesc,
1912 &curr_piece_source_value);
1918 switch (curr_piece_source_value_type) {
1920 return llvm::createStringError(
"invalid value type");
1927 return llvm::createStringError(
1928 "unable to convert file address 0x%" PRIx64
1930 "for DW_OP_piece(%" PRIu64
"): "
1931 "no target available",
1932 addr, piece_byte_size);
1937 if (curr_piece.
ResizeData(piece_byte_size) == piece_byte_size) {
1939 piece_byte_size,
error,
1942 const char *addr_type = (curr_piece_source_value_type ==
1946 return llvm::createStringError(
1947 "failed to read memory DW_OP_piece(%" PRIu64
1948 ") from %s address 0x%" PRIx64,
1949 piece_byte_size, addr_type, addr);
1952 return llvm::createStringError(
1953 "failed to resize the piece memory buffer for "
1954 "DW_OP_piece(%" PRIu64
")",
1960 return llvm::createStringError(
1961 "failed to read memory DW_OP_piece(%" PRIu64
1962 ") from host address 0x%" PRIx64,
1963 piece_byte_size, addr);
1967 uint32_t bit_size = piece_byte_size * 8;
1968 uint32_t bit_offset = 0;
1970 return llvm::createStringError(
1971 "unable to extract %" PRIu64
" bytes from a %" PRIu64
1972 " byte scalar value.",
1987 if (op_piece_offset == 0) {
1992 return llvm::createStringError(
"failed to append piece data");
1998 return llvm::createStringError(
1999 "DW_OP_piece for offset %" PRIu64
2000 " but top of stack is of size %" PRIu64,
2005 return llvm::createStringError(
"failed to append piece data");
2008 op_piece_offset += piece_byte_size;
2012 case DW_OP_bit_piece:
2013 if (stack.size() < 1) {
2014 UpdateValueTypeFromLocationDescription(log, dwarf_cu,
2015 LocationDescriptionKind::Empty);
2017 dwarf4_location_description_kind =
Memory;
2018 return llvm::createStringError(
2019 "expression stack needs at least 1 item for DW_OP_bit_piece");
2021 UpdateValueTypeFromLocationDescription(
2022 log, dwarf_cu, dwarf4_location_description_kind, &stack.back());
2024 dwarf4_location_description_kind =
Memory;
2025 const uint64_t piece_bit_size = opcodes.
GetULEB128(&offset);
2026 const uint64_t piece_bit_offset = opcodes.
GetULEB128(&offset);
2027 switch (stack.back().GetValueType()) {
2029 return llvm::createStringError(
2030 "unable to extract bit value from invalid value");
2032 if (!stack.back().GetScalar().ExtractBitfield(piece_bit_size,
2033 piece_bit_offset)) {
2034 return llvm::createStringError(
2035 "unable to extract %" PRIu64
" bit value with %" PRIu64
2036 " bit offset from a %" PRIu64
" bit scalar value.",
2037 piece_bit_size, piece_bit_offset,
2038 (uint64_t)(stack.back().GetScalar().GetByteSize() * 8));
2045 return llvm::createStringError(
2046 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64
2047 ", bit_offset = %" PRIu64
") from an address value.",
2048 piece_bit_size, piece_bit_offset);
2060 case DW_OP_implicit_value: {
2061 dwarf4_location_description_kind = Implicit;
2063 const uint32_t len = opcodes.
GetULEB128(&offset);
2064 const void *data = opcodes.
GetData(&offset, len);
2067 LLDB_LOG(log,
"Evaluate_DW_OP_implicit_value: could not be read data");
2068 return llvm::createStringError(
"could not evaluate %s",
2072 Value result(data, len);
2073 stack.push_back(result);
2077 case DW_OP_implicit_pointer: {
2078 dwarf4_location_description_kind = Implicit;
2079 return llvm::createStringError(
"could not evaluate %s",
2091 case DW_OP_push_object_address:
2092 if (object_address_ptr)
2093 stack.push_back(*object_address_ptr);
2095 return llvm::createStringError(
"DW_OP_push_object_address used without "
2096 "specifying an object address");
2119 return llvm::createStringError(
"unimplemented opcode DW_OP_call2");
2140 return llvm::createStringError(
"unimplemented opcode DW_OP_call4");
2147 case DW_OP_stack_value:
2148 dwarf4_location_description_kind = Implicit;
2159 case DW_OP_convert: {
2160 const uint64_t relative_die_offset = opcodes.
GetULEB128(&offset);
2163 if (relative_die_offset == 0) {
2168 return llvm::createStringError(
"no module");
2170 bit_size = module_sp->GetArchitecture().GetAddressByteSize() * 8;
2172 return llvm::createStringError(
"unspecified architecture");
2174 auto bit_size_sign_or_err =
2176 if (!bit_size_sign_or_err)
2177 return bit_size_sign_or_err.takeError();
2178 bit_size = bit_size_sign_or_err->first;
2179 sign = bit_size_sign_or_err->second;
2181 Scalar &top = stack.back().ResolveValue(exe_ctx);
2191 case DW_OP_call_frame_cfa:
2196 addr_t cfa =
id.GetCallFrameAddressWithMetadata();
2198 stack.push_back(
Scalar(cfa));
2201 return llvm::createStringError(
2202 "stack frame does not include a canonical "
2203 "frame address for DW_OP_call_frame_cfa "
2207 return llvm::createStringError(
"unvalid stack frame in context for "
2208 "DW_OP_call_frame_cfa opcode");
2218 case DW_OP_form_tls_address:
2219 case DW_OP_GNU_push_tls_address: {
2220 if (stack.size() < 1) {
2221 if (op == DW_OP_form_tls_address)
2222 return llvm::createStringError(
2223 "DW_OP_form_tls_address needs an argument");
2225 return llvm::createStringError(
2226 "DW_OP_GNU_push_tls_address needs an argument");
2229 if (!exe_ctx || !module_sp)
2230 return llvm::createStringError(
"no context to evaluate TLS within");
2234 return llvm::createStringError(
"no thread to evaluate TLS within");
2237 const addr_t tls_file_addr =
2239 const addr_t tls_load_addr =
2240 thread->GetThreadLocalData(module_sp, tls_file_addr);
2243 return llvm::createStringError(
2244 "no TLS data currently exists for this thread");
2246 stack.back().GetScalar() = tls_load_addr;
2257 case DW_OP_GNU_addr_index: {
2259 return llvm::createStringError(
"DW_OP_GNU_addr_index found without a "
2260 "compile unit being specified");
2261 uint64_t index = opcodes.
GetULEB128(&offset);
2263 stack.push_back(
Scalar(value));
2281 case DW_OP_GNU_const_index: {
2283 return llvm::createStringError(
"DW_OP_GNU_const_index found without a "
2284 "compile unit being specified");
2286 uint64_t index = opcodes.
GetULEB128(&offset);
2288 stack.push_back(
Scalar(value));
2291 case DW_OP_GNU_entry_value:
2292 case DW_OP_entry_value: {
2294 opcodes, offset, log))
2295 return llvm::createStringError(
2296 "could not evaluate DW_OP_entry_value: %s",
2297 llvm::toString(std::move(err)).c_str());
2308 return llvm::createStringError(llvm::formatv(
2309 "Unhandled opcode {0} in DWARFExpression", LocationAtom(op)));
2313 if (stack.empty()) {
2319 return llvm::createStringError(
"stack empty after evaluation");
2322 UpdateValueTypeFromLocationDescription(
2323 log, dwarf_cu, dwarf4_location_description_kind, &stack.back());
2326 size_t count = stack.size();
2328 "Stack after operation has %" PRIu64
" values:", (uint64_t)count);
2329 for (
size_t i = 0; i < count; ++i) {
2331 new_value.
Printf(
"[%" PRIu64
"]", (uint64_t)i);
2332 stack[i].Dump(&new_value);
2336 return stack.back();