LLDB mainline
ABI.cpp
Go to the documentation of this file.
1//===-- ABI.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/Target/ABI.h"
11#include "lldb/Core/Value.h"
16#include "lldb/Target/Target.h"
17#include "lldb/Target/Thread.h"
19#include "lldb/Utility/Log.h"
20#include "llvm/MC/TargetRegistry.h"
21#include <cctype>
22
23using namespace lldb;
24using namespace lldb_private;
25
27ABI::FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch) {
28 ABISP abi_sp;
29 ABICreateInstance create_callback;
30
31 for (uint32_t idx = 0;
32 (create_callback = PluginManager::GetABICreateCallbackAtIndex(idx)) !=
33 nullptr;
34 ++idx) {
35 abi_sp = create_callback(process_sp, arch);
36
37 if (abi_sp)
38 return abi_sp;
39 }
40 abi_sp.reset();
41 return abi_sp;
42}
43
44ABI::~ABI() = default;
45
47 RegisterInfo &info) {
48 uint32_t count = 0;
49 const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
50 if (register_info_array) {
51 uint32_t i;
52 for (i = 0; i < count; ++i) {
53 const char *reg_name = register_info_array[i].name;
54 if (reg_name == name) {
55 info = register_info_array[i];
56 return true;
57 }
58 }
59 for (i = 0; i < count; ++i) {
60 const char *reg_alt_name = register_info_array[i].alt_name;
61 if (reg_alt_name == name) {
62 info = register_info_array[i];
63 return true;
64 }
65 }
66 }
67 return false;
68}
69
71 bool persistent) const {
72 if (!ast_type.IsValid())
73 return ValueObjectSP();
74
75 ValueObjectSP return_valobj_sp;
76
77 return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
78 if (!return_valobj_sp)
79 return return_valobj_sp;
80
81 // Now turn this into a persistent variable.
82 // FIXME: This code is duplicated from Target::EvaluateExpression, and it is
83 // used in similar form in a couple
84 // of other places. Figure out the correct Create function to do all this
85 // work.
86
87 if (persistent) {
88 Target &target = *thread.CalculateTarget();
89 PersistentExpressionState *persistent_expression_state =
91 ast_type.GetMinimumLanguage());
92
93 if (!persistent_expression_state)
94 return {};
95
96 ConstString persistent_variable_name =
97 persistent_expression_state->GetNextPersistentVariableName();
98
99 lldb::ValueObjectSP const_valobj_sp;
100
101 // Check in case our value is already a constant value
102 if (return_valobj_sp->GetIsConstant()) {
103 const_valobj_sp = return_valobj_sp;
104 const_valobj_sp->SetName(persistent_variable_name);
105 } else
106 const_valobj_sp =
107 return_valobj_sp->CreateConstantValue(persistent_variable_name);
108
109 lldb::ValueObjectSP live_valobj_sp = return_valobj_sp;
110
111 return_valobj_sp = const_valobj_sp;
112
113 ExpressionVariableSP expr_variable_sp(
114 persistent_expression_state->CreatePersistentVariable(
115 return_valobj_sp));
116
117 assert(expr_variable_sp);
118
119 // Set flags and live data as appropriate
120
121 const Value &result_value = live_valobj_sp->GetValue();
122
123 switch (result_value.GetValueType()) {
125 return {};
128 // we odon't do anything with these for now
129 break;
131 expr_variable_sp->m_flags |=
133 expr_variable_sp->m_flags |=
135 expr_variable_sp->m_flags |=
137 break;
139 expr_variable_sp->m_live_sp = live_valobj_sp;
140 expr_variable_sp->m_flags |=
142 break;
143 }
144
145 return_valobj_sp = expr_variable_sp->GetValueObject();
146 }
147 return return_valobj_sp;
148}
149
150ValueObjectSP ABI::GetReturnValueObject(Thread &thread, llvm::Type &ast_type,
151 bool persistent) const {
152 ValueObjectSP return_valobj_sp;
153 return_valobj_sp = GetReturnValueObjectImpl(thread, ast_type);
154 return return_valobj_sp;
155}
156
157// specialized to work with llvm IR types
158//
159// for now we will specify a default implementation so that we don't need to
160// modify other ABIs
162 llvm::Type &ir_type) const {
163 ValueObjectSP return_valobj_sp;
164
165 /* this is a dummy and will only be called if an ABI does not override this */
166
167 return return_valobj_sp;
168}
169
171 lldb::addr_t functionAddress,
172 lldb::addr_t returnAddress, llvm::Type &returntype,
173 llvm::ArrayRef<ABI::CallArgument> args) const {
174 // dummy prepare trivial call
175 llvm_unreachable("Should never get here!");
176}
177
179 const RegisterInfo *reg_info,
180 UnwindPlan::Row::RegisterLocation &unwind_regloc) {
181 // Did the UnwindPlan fail to give us the caller's stack pointer? The stack
182 // pointer is defined to be the same as THIS frame's CFA, so return the CFA
183 // value as the caller's stack pointer. This is true on x86-32/x86-64 at
184 // least.
186 unwind_regloc.SetIsCFAPlusOffset(0);
187 return true;
188 }
189
190 // If a volatile register is being requested, we don't want to forward the
191 // next frame's register contents up the stack -- the register is not
192 // retrievable at this frame.
193 if (RegisterIsVolatile(reg_info)) {
194 unwind_regloc.SetUndefined();
195 return true;
196 }
197
198 return false;
199}
200
201std::unique_ptr<llvm::MCRegisterInfo> ABI::MakeMCRegisterInfo(const ArchSpec &arch) {
202 std::string triple = arch.GetTriple().getTriple();
203 std::string lookup_error;
204 const llvm::Target *target =
205 llvm::TargetRegistry::lookupTarget(triple, lookup_error);
206 if (!target) {
208 "Failed to create an llvm target for {0}: {1}", triple,
209 lookup_error);
210 return nullptr;
211 }
212 std::unique_ptr<llvm::MCRegisterInfo> info_up(
213 target->createMCRegInfo(triple));
214 assert(info_up);
215 return info_up;
216}
217
219 std::vector<DynamicRegisterInfo::Register> &regs) {
220 for (DynamicRegisterInfo::Register &info : regs) {
221 if (info.regnum_ehframe != LLDB_INVALID_REGNUM &&
222 info.regnum_dwarf != LLDB_INVALID_REGNUM)
223 continue;
224
225 RegisterInfo abi_info;
226 if (!GetRegisterInfoByName(info.name.GetStringRef(), abi_info))
227 continue;
228
229 if (info.regnum_ehframe == LLDB_INVALID_REGNUM)
230 info.regnum_ehframe = abi_info.kinds[eRegisterKindEHFrame];
231 if (info.regnum_dwarf == LLDB_INVALID_REGNUM)
232 info.regnum_dwarf = abi_info.kinds[eRegisterKindDWARF];
233 if (info.regnum_generic == LLDB_INVALID_REGNUM)
234 info.regnum_generic = abi_info.kinds[eRegisterKindGeneric];
235 }
236}
237
239 std::vector<DynamicRegisterInfo::Register> &regs) {
240 for (DynamicRegisterInfo::Register &info : regs) {
241 uint32_t eh, dwarf;
242 std::tie(eh, dwarf) = GetEHAndDWARFNums(info.name.GetStringRef());
243
244 if (info.regnum_ehframe == LLDB_INVALID_REGNUM)
245 info.regnum_ehframe = eh;
246 if (info.regnum_dwarf == LLDB_INVALID_REGNUM)
247 info.regnum_dwarf = dwarf;
248 if (info.regnum_generic == LLDB_INVALID_REGNUM)
249 info.regnum_generic = GetGenericNum(info.name.GetStringRef());
250 }
251}
252
253std::pair<uint32_t, uint32_t>
254MCBasedABI::GetEHAndDWARFNums(llvm::StringRef name) {
255 std::string mc_name = GetMCName(name.str());
256 for (char &c : mc_name)
257 c = std::toupper(c);
258 int eh = -1;
259 int dwarf = -1;
260 for (unsigned reg = 0; reg < m_mc_register_info_up->getNumRegs(); ++reg) {
261 if (m_mc_register_info_up->getName(reg) == mc_name) {
262 eh = m_mc_register_info_up->getDwarfRegNum(reg, /*isEH=*/true);
263 dwarf = m_mc_register_info_up->getDwarfRegNum(reg, /*isEH=*/false);
264 break;
265 }
266 }
267 return std::pair<uint32_t, uint32_t>(eh == -1 ? LLDB_INVALID_REGNUM : eh,
269 : dwarf);
270}
271
272void MCBasedABI::MapRegisterName(std::string &name, llvm::StringRef from_prefix,
273 llvm::StringRef to_prefix) {
274 llvm::StringRef name_ref = name;
275 if (!name_ref.consume_front(from_prefix))
276 return;
277 uint64_t _;
278 if (name_ref.empty() || to_integer(name_ref, _, 10))
279 name = (to_prefix + name_ref).str();
280}
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:342
virtual lldb::ValueObjectSP GetReturnValueObjectImpl(Thread &thread, CompilerType &ast_type) const =0
static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch)
Definition: ABI.cpp:27
virtual bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp, lldb::addr_t functionAddress, lldb::addr_t returnAddress, llvm::ArrayRef< lldb::addr_t > args) const =0
virtual bool GetFallbackRegisterLocation(const RegisterInfo *reg_info, UnwindPlan::Row::RegisterLocation &unwind_regloc)
Definition: ABI.cpp:178
lldb::ValueObjectSP GetReturnValueObject(Thread &thread, CompilerType &type, bool persistent=true) const
Definition: ABI.cpp:70
static std::unique_ptr< llvm::MCRegisterInfo > MakeMCRegisterInfo(const ArchSpec &arch)
Utility function to construct a MCRegisterInfo using the ArchSpec triple.
Definition: ABI.cpp:201
virtual bool RegisterIsVolatile(const RegisterInfo *reg_info)=0
std::unique_ptr< llvm::MCRegisterInfo > m_mc_register_info_up
Definition: ABI.h:167
An architecture specification class.
Definition: ArchSpec.h:31
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
lldb::LanguageType GetMinimumLanguage()
A uniqued constant string class.
Definition: ConstString.h:40
@ EVIsLLDBAllocated
This variable is resident in a location specifically allocated for it by LLDB in the target process.
@ EVNeedsAllocation
Space for this variable has yet to be allocated in the target process.
@ EVIsProgramReference
This variable is a reference to a (possibly invalid) area managed by the target program.
@ EVIsFreezeDried
This variable's authoritative version is in m_frozen_sp (for example, for statically-computed results...
virtual std::string GetMCName(std::string reg)
For the given (capitalized) lldb register name, return the name of this register in the MCRegisterInf...
Definition: ABI.h:212
void AugmentRegisterInfo(std::vector< DynamicRegisterInfo::Register > &regs) override
Definition: ABI.cpp:238
virtual uint32_t GetGenericNum(llvm::StringRef reg)=0
Return the generic number of the given register.
virtual std::pair< uint32_t, uint32_t > GetEHAndDWARFNums(llvm::StringRef reg)
Return eh_frame and dwarf numbers for the given register.
Definition: ABI.cpp:254
static void MapRegisterName(std::string &reg, llvm::StringRef from_prefix, llvm::StringRef to_prefix)
If the register name is of the form "<from_prefix>[<number>]" then change the name to "<to_prefix>[<n...
Definition: ABI.cpp:272
virtual lldb::ExpressionVariableSP CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp)=0
virtual ConstString GetNextPersistentVariableName(bool is_error=false)=0
Return a new persistent variable name with the specified prefix.
static ABICreateInstance GetABICreateCallbackAtIndex(uint32_t idx)
bool GetRegisterInfoByName(llvm::StringRef name, RegisterInfo &info)
Definition: ABI.cpp:46
virtual const RegisterInfo * GetRegisterInfoArray(uint32_t &count)=0
void AugmentRegisterInfo(std::vector< DynamicRegisterInfo::Register > &regs) override
Definition: ABI.cpp:218
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2491
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1390
@ HostAddress
A host address value (for memory in the process that < A is using liblldb).
@ FileAddress
A file address value.
@ LoadAddress
A load address value.
@ Scalar
A raw scalar value.
ValueType GetValueType() const
Definition: Value.cpp:109
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:57
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:87
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
lldb::ABISP(* ABICreateInstance)(lldb::ProcessSP process_sp, const ArchSpec &arch)
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ABI > ABISP
Definition: lldb-forward.h:310
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:472
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:343
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
uint64_t addr_t
Definition: lldb-types.h:79
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
@ eRegisterKindDWARF
the register numbers seen DWARF
@ eRegisterKindEHFrame
the register numbers seen in eh_frame
Every register is described in detail including its name, alternate name (optional),...
const char * alt_name
Alternate name of this register, can be NULL.
uint32_t kinds[lldb::kNumRegisterKinds]
Holds all of the various register numbers for all register kinds.
const char * name
Name of this register, can't be NULL.