1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
| //===-- ABI.h ---------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ABI_h_
#define liblldb_ABI_h_
#include "lldb/Core/PluginInterface.h"
#include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/MC/MCRegisterInfo.h"
namespace llvm {
class Type;
}
namespace lldb_private {
class ABI : public PluginInterface {
public:
struct CallArgument {
enum eType {
HostPointer = 0, /* pointer to host data */
TargetValue, /* value is on the target or literal */
};
eType type; /* value of eType */
size_t size; /* size in bytes of this argument */
lldb::addr_t value; /* literal value */
std::unique_ptr<uint8_t[]> data_up; /* host data pointer */
};
~ABI() override;
virtual size_t GetRedZoneSize() const = 0;
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;
// Prepare trivial call used from ThreadPlanFunctionCallUsingABI
// AD:
// . Because i don't want to change other ABI's this is not declared pure
// virtual.
// The dummy implementation will simply fail. Only HexagonABI will
// currently
// use this method.
// . Two PrepareTrivialCall's is not good design so perhaps this should be
// combined.
//
virtual bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
lldb::addr_t functionAddress,
lldb::addr_t returnAddress,
llvm::Type &prototype,
llvm::ArrayRef<CallArgument> args) const;
virtual bool GetArgumentValues(Thread &thread, ValueList &values) const = 0;
lldb::ValueObjectSP GetReturnValueObject(Thread &thread, CompilerType &type,
bool persistent = true) const;
// specialized to work with llvm IR types
lldb::ValueObjectSP GetReturnValueObject(Thread &thread, llvm::Type &type,
bool persistent = true) const;
// Set the Return value object in the current frame as though a function with
virtual Status SetReturnValueObject(lldb::StackFrameSP &frame_sp,
lldb::ValueObjectSP &new_value) = 0;
protected:
// This is the method the ABI will call to actually calculate the return
// value. Don't put it in a persistent value object, that will be done by the
// ABI::GetReturnValueObject.
virtual lldb::ValueObjectSP
GetReturnValueObjectImpl(Thread &thread, CompilerType &ast_type) const = 0;
// specialized to work with llvm IR types
virtual lldb::ValueObjectSP
GetReturnValueObjectImpl(Thread &thread, llvm::Type &ir_type) const;
/// Request to get a Process shared pointer.
///
/// This ABI object may not have been created with a Process object,
/// or the Process object may no longer be alive. Be sure to handle
/// the case where the shared pointer returned does not have an
/// object inside it.
lldb::ProcessSP GetProcessSP() const { return m_process_wp.lock(); }
public:
virtual bool CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) = 0;
virtual bool CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) = 0;
virtual bool RegisterIsVolatile(const RegisterInfo *reg_info) = 0;
virtual bool
GetFallbackRegisterLocation(const RegisterInfo *reg_info,
UnwindPlan::Row::RegisterLocation &unwind_regloc);
// Should take a look at a call frame address (CFA) which is just the stack
// pointer value upon entry to a function. ABIs usually impose alignment
// restrictions (4, 8 or 16 byte aligned), and zero is usually not allowed.
// This function should return true if "cfa" is valid call frame address for
// the ABI, and false otherwise. This is used by the generic stack frame
// unwinding code to help determine when a stack ends.
virtual bool CallFrameAddressIsValid(lldb::addr_t cfa) = 0;
// Validates a possible PC value and returns true if an opcode can be at
// "pc".
virtual bool CodeAddressIsValid(lldb::addr_t pc) = 0;
virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) {
// Some targets might use bits in a code address to indicate a mode switch.
// ARM uses bit zero to signify a code address is thumb, so any ARM ABI
// plug-ins would strip those bits.
return pc;
}
llvm::MCRegisterInfo &GetMCRegisterInfo() { return *m_mc_register_info_up; }
virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
bool GetRegisterInfoByName(ConstString name, RegisterInfo &info);
bool GetRegisterInfoByKind(lldb::RegisterKind reg_kind, uint32_t reg_num,
RegisterInfo &info);
virtual bool GetPointerReturnRegister(const char *&name) { return false; }
static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);
protected:
ABI(lldb::ProcessSP process_sp, std::unique_ptr<llvm::MCRegisterInfo> info_up)
: m_process_wp(process_sp), m_mc_register_info_up(std::move(info_up)) {
assert(m_mc_register_info_up && "ABI must have MCRegisterInfo");
}
/// Utility function to construct a MCRegisterInfo using the ArchSpec triple.
/// Plugins wishing to customize the construction can construct the
/// MCRegisterInfo themselves.
static std::unique_ptr<llvm::MCRegisterInfo>
MakeMCRegisterInfo(const ArchSpec &arch);
lldb::ProcessWP m_process_wp;
std::unique_ptr<llvm::MCRegisterInfo> m_mc_register_info_up;
private:
DISALLOW_COPY_AND_ASSIGN(ABI);
};
} // namespace lldb_private
#endif // liblldb_ABI_h_
|