1 //===-- DWARFExpressionList.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/DWARFExpressionList.h" 10 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h" 11 #include "lldb/Symbol/Function.h" 12 #include "lldb/Target/RegisterContext.h" 13 #include "lldb/Target/StackFrame.h" 14 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h" 15 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 16 17 using namespace lldb; 18 using namespace lldb_private; 19 20 bool DWARFExpressionList::IsAlwaysValidSingleExpr() const { 21 return GetAlwaysValidExpr() != nullptr; 22 } 23 24 const DWARFExpression * DWARFExpressionList::GetAlwaysValidExpr() const { 25 if (m_exprs.GetSize() != 1) 26 return nullptr; 27 const auto *expr = m_exprs.GetEntryAtIndex(0); 28 if (expr->base == 0 && expr->size == LLDB_INVALID_ADDRESS) 29 return &expr->data; 30 return nullptr; 31 } 32 33 bool DWARFExpressionList::AddExpression(addr_t base, addr_t end, 34 DWARFExpression expr) { 35 if (IsAlwaysValidSingleExpr() || base >= end) 36 return false; 37 m_exprs.Append({base, end - base, expr}); 38 return true; 39 } 40 41 bool DWARFExpressionList::GetExpressionData(DataExtractor &data, 42 lldb::addr_t func_load_addr, 43 lldb::addr_t file_addr) const { 44 if (const DWARFExpression *expr = 45 GetExpressionAtAddress(func_load_addr, file_addr)) 46 return expr->GetExpressionData(data); 47 return false; 48 } 49 50 bool DWARFExpressionList::ContainsAddress(lldb::addr_t func_load_addr, 51 lldb::addr_t addr) const { 52 if (IsAlwaysValidSingleExpr()) 53 return true; 54 return GetExpressionAtAddress(func_load_addr, addr) != nullptr; 55 } 56 57 const DWARFExpression * 58 DWARFExpressionList::GetExpressionAtAddress(lldb::addr_t func_load_addr, 59 lldb::addr_t load_addr) const { 60 if (const DWARFExpression *expr = GetAlwaysValidExpr()) 61 return expr; 62 if (func_load_addr == LLDB_INVALID_ADDRESS) 63 func_load_addr = m_func_file_addr; 64 addr_t addr = load_addr - func_load_addr + m_func_file_addr; 65 uint32_t index = m_exprs.FindEntryIndexThatContains(addr); 66 if (index == UINT32_MAX) 67 return nullptr; 68 return &m_exprs.GetEntryAtIndex(index)->data; 69 } 70 71 DWARFExpression * 72 DWARFExpressionList::GetMutableExpressionAtAddress(lldb::addr_t func_load_addr, 73 lldb::addr_t load_addr) { 74 if (IsAlwaysValidSingleExpr()) 75 return &m_exprs.GetMutableEntryAtIndex(0)->data; 76 if (func_load_addr == LLDB_INVALID_ADDRESS) 77 func_load_addr = m_func_file_addr; 78 addr_t addr = load_addr - func_load_addr + m_func_file_addr; 79 uint32_t index = m_exprs.FindEntryIndexThatContains(addr); 80 if (index == UINT32_MAX) 81 return nullptr; 82 return &m_exprs.GetMutableEntryAtIndex(index)->data; 83 } 84 85 bool DWARFExpressionList::ContainsThreadLocalStorage() const { 86 // We are assuming for now that any thread local variable will not have a 87 // location list. This has been true for all thread local variables we have 88 // seen so far produced by any compiler. 89 if (!IsAlwaysValidSingleExpr()) 90 return false; 91 92 const DWARFExpression &expr = m_exprs.GetEntryRef(0).data; 93 return expr.ContainsThreadLocalStorage(m_dwarf_cu); 94 } 95 96 bool DWARFExpressionList::LinkThreadLocalStorage( 97 lldb::ModuleSP new_module_sp, 98 std::function<lldb::addr_t(lldb::addr_t file_addr)> const 99 &link_address_callback) { 100 // We are assuming for now that any thread local variable will not have a 101 // location list. This has been true for all thread local variables we have 102 // seen so far produced by any compiler. 103 if (!IsAlwaysValidSingleExpr()) 104 return false; 105 106 DWARFExpression &expr = m_exprs.GetEntryRef(0).data; 107 // If we linked the TLS address correctly, update the module so that when the 108 // expression is evaluated it can resolve the file address to a load address 109 // and read the TLS data 110 if (expr.LinkThreadLocalStorage(m_dwarf_cu, link_address_callback)) 111 m_module_wp = new_module_sp; 112 return true; 113 } 114 115 bool DWARFExpressionList::MatchesOperand( 116 StackFrame &frame, const Instruction::Operand &operand) const { 117 RegisterContextSP reg_ctx_sp = frame.GetRegisterContext(); 118 if (!reg_ctx_sp) { 119 return false; 120 } 121 const DWARFExpression *expr = nullptr; 122 if (IsAlwaysValidSingleExpr()) 123 expr = &m_exprs.GetEntryAtIndex(0)->data; 124 else { 125 SymbolContext sc = frame.GetSymbolContext(eSymbolContextFunction); 126 if (!sc.function) 127 return false; 128 129 addr_t load_function_start = sc.function->GetAddress().GetFileAddress(); 130 if (load_function_start == LLDB_INVALID_ADDRESS) 131 return false; 132 133 addr_t pc = frame.GetFrameCodeAddressForSymbolication().GetFileAddress(); 134 expr = GetExpressionAtAddress(LLDB_INVALID_ADDRESS, pc); 135 } 136 if (!expr) 137 return false; 138 return expr->MatchesOperand(frame, operand); 139 } 140 141 bool DWARFExpressionList::DumpLocations(Stream *s, lldb::DescriptionLevel level, 142 lldb::addr_t func_load_addr, 143 lldb::addr_t file_addr, 144 ABI *abi) const { 145 llvm::raw_ostream &os = s->AsRawOstream(); 146 llvm::ListSeparator separator; 147 if (const DWARFExpression *expr = GetAlwaysValidExpr()) { 148 expr->DumpLocation(s, level, abi); 149 return true; 150 } 151 for (const Entry &entry : *this) { 152 addr_t load_base = entry.GetRangeBase() + func_load_addr - m_func_file_addr; 153 addr_t load_end = entry.GetRangeEnd() + func_load_addr - m_func_file_addr; 154 if (file_addr != LLDB_INVALID_ADDRESS && 155 (file_addr < load_base || file_addr >= load_end)) 156 continue; 157 const auto &expr = entry.data; 158 DataExtractor data; 159 expr.GetExpressionData(data); 160 uint32_t addr_size = data.GetAddressByteSize(); 161 162 os << separator; 163 os << "["; 164 os << llvm::format_hex(load_base, 2 + 2 * addr_size); 165 os << ", "; 166 os << llvm::format_hex(load_end, 2 + 2 * addr_size); 167 os << ") -> "; 168 expr.DumpLocation(s, level, abi); 169 if (file_addr != LLDB_INVALID_ADDRESS) 170 break; 171 } 172 return true; 173 } 174 175 void DWARFExpressionList::GetDescription(Stream *s, 176 lldb::DescriptionLevel level, 177 ABI *abi) const { 178 llvm::raw_ostream &os = s->AsRawOstream(); 179 if (IsAlwaysValidSingleExpr()) { 180 m_exprs.Back()->data.DumpLocation(s, level, abi); 181 return; 182 } 183 os << llvm::format("0x%8.8" PRIx64 ": ", 0); 184 for (const Entry &entry : *this) { 185 const auto &expr = entry.data; 186 DataExtractor data; 187 expr.GetExpressionData(data); 188 uint32_t addr_size = data.GetAddressByteSize(); 189 os << "\n"; 190 os.indent(s->GetIndentLevel() + 2); 191 os << "["; 192 llvm::DWARFFormValue::dumpAddress(os, addr_size, entry.GetRangeBase()); 193 os << ", "; 194 llvm::DWARFFormValue::dumpAddress(os, addr_size, entry.GetRangeEnd()); 195 os << "): "; 196 expr.DumpLocation(s, level, abi); 197 } 198 } 199 200 llvm::Expected<Value> DWARFExpressionList::Evaluate( 201 ExecutionContext *exe_ctx, RegisterContext *reg_ctx, 202 lldb::addr_t func_load_addr, const Value *initial_value_ptr, 203 const Value *object_address_ptr) const { 204 ModuleSP module_sp = m_module_wp.lock(); 205 DataExtractor data; 206 RegisterKind reg_kind; 207 DWARFExpression expr; 208 if (IsAlwaysValidSingleExpr()) { 209 expr = m_exprs.Back()->data; 210 } else { 211 Address pc; 212 StackFrame *frame = nullptr; 213 if (!reg_ctx || !reg_ctx->GetPCForSymbolication(pc)) { 214 if (exe_ctx) 215 frame = exe_ctx->GetFramePtr(); 216 if (!frame) 217 return llvm::createStringError("no frame"); 218 RegisterContextSP reg_ctx_sp = frame->GetRegisterContext(); 219 if (!reg_ctx_sp) 220 return llvm::createStringError("no register context"); 221 reg_ctx_sp->GetPCForSymbolication(pc); 222 } 223 224 if (!pc.IsValid()) { 225 return llvm::createStringError("Invalid PC in frame."); 226 } 227 addr_t pc_load_addr = pc.GetLoadAddress(exe_ctx->GetTargetPtr()); 228 const DWARFExpression *entry = 229 GetExpressionAtAddress(func_load_addr, pc_load_addr); 230 if (!entry) 231 return llvm::createStringError("variable not available"); 232 expr = *entry; 233 } 234 expr.GetExpressionData(data); 235 reg_kind = expr.GetRegisterKind(); 236 return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, data, 237 m_dwarf_cu, reg_kind, initial_value_ptr, 238 object_address_ptr); 239 } 240