1 | //===-- ABI.h ---------------------------------------------------*- C++ -*-===// |
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 | #ifndef LLDB_TARGET_ABI_H |
10 | #define LLDB_TARGET_ABI_H |
11 | |
12 | #include "lldb/Core/PluginInterface.h" |
13 | #include "lldb/Symbol/UnwindPlan.h" |
14 | #include "lldb/Target/DynamicRegisterInfo.h" |
15 | #include "lldb/Utility/Status.h" |
16 | #include "lldb/lldb-private.h" |
17 | |
18 | #include "llvm/ADT/ArrayRef.h" |
19 | #include "llvm/MC/MCRegisterInfo.h" |
20 | |
21 | namespace llvm { |
22 | class Type; |
23 | } |
24 | |
25 | namespace lldb_private { |
26 | |
27 | class ABI : public PluginInterface { |
28 | public: |
29 | struct CallArgument { |
30 | enum eType { |
31 | HostPointer = 0, /* pointer to host data */ |
32 | TargetValue, /* value is on the target or literal */ |
33 | }; |
34 | eType type; /* value of eType */ |
35 | size_t size; /* size in bytes of this argument */ |
36 | |
37 | lldb::addr_t value; /* literal value */ |
38 | std::unique_ptr<uint8_t[]> data_up; /* host data pointer */ |
39 | }; |
40 | |
41 | ~ABI() override; |
42 | |
43 | virtual size_t GetRedZoneSize() const = 0; |
44 | |
45 | virtual bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp, |
46 | lldb::addr_t functionAddress, |
47 | lldb::addr_t returnAddress, |
48 | llvm::ArrayRef<lldb::addr_t> args) const = 0; |
49 | |
50 | // Prepare trivial call used from ThreadPlanFunctionCallUsingABI |
51 | // AD: |
52 | // . Because i don't want to change other ABI's this is not declared pure |
53 | // virtual. |
54 | // The dummy implementation will simply fail. Only HexagonABI will |
55 | // currently |
56 | // use this method. |
57 | // . Two PrepareTrivialCall's is not good design so perhaps this should be |
58 | // combined. |
59 | // |
60 | virtual bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp, |
61 | lldb::addr_t functionAddress, |
62 | lldb::addr_t returnAddress, |
63 | llvm::Type &prototype, |
64 | llvm::ArrayRef<CallArgument> args) const; |
65 | |
66 | virtual bool GetArgumentValues(Thread &thread, ValueList &values) const = 0; |
67 | |
68 | lldb::ValueObjectSP GetReturnValueObject(Thread &thread, CompilerType &type, |
69 | bool persistent = true) const; |
70 | |
71 | // specialized to work with llvm IR types |
72 | lldb::ValueObjectSP GetReturnValueObject(Thread &thread, llvm::Type &type, |
73 | bool persistent = true) const; |
74 | |
75 | // Set the Return value object in the current frame as though a function with |
76 | virtual Status SetReturnValueObject(lldb::StackFrameSP &frame_sp, |
77 | lldb::ValueObjectSP &new_value) = 0; |
78 | |
79 | protected: |
80 | // This is the method the ABI will call to actually calculate the return |
81 | // value. Don't put it in a persistent value object, that will be done by the |
82 | // ABI::GetReturnValueObject. |
83 | virtual lldb::ValueObjectSP |
84 | GetReturnValueObjectImpl(Thread &thread, CompilerType &ast_type) const = 0; |
85 | |
86 | // specialized to work with llvm IR types |
87 | virtual lldb::ValueObjectSP |
88 | GetReturnValueObjectImpl(Thread &thread, llvm::Type &ir_type) const; |
89 | |
90 | /// Request to get a Process shared pointer. |
91 | /// |
92 | /// This ABI object may not have been created with a Process object, |
93 | /// or the Process object may no longer be alive. Be sure to handle |
94 | /// the case where the shared pointer returned does not have an |
95 | /// object inside it. |
96 | lldb::ProcessSP GetProcessSP() const { return m_process_wp.lock(); } |
97 | |
98 | public: |
99 | virtual bool CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) = 0; |
100 | |
101 | virtual bool CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) = 0; |
102 | |
103 | virtual bool RegisterIsVolatile(const RegisterInfo *reg_info) = 0; |
104 | |
105 | virtual bool |
106 | GetFallbackRegisterLocation(const RegisterInfo *reg_info, |
107 | UnwindPlan::Row::RegisterLocation &unwind_regloc); |
108 | |
109 | // Should take a look at a call frame address (CFA) which is just the stack |
110 | // pointer value upon entry to a function. ABIs usually impose alignment |
111 | // restrictions (4, 8 or 16 byte aligned), and zero is usually not allowed. |
112 | // This function should return true if "cfa" is valid call frame address for |
113 | // the ABI, and false otherwise. This is used by the generic stack frame |
114 | // unwinding code to help determine when a stack ends. |
115 | virtual bool CallFrameAddressIsValid(lldb::addr_t cfa) = 0; |
116 | |
117 | // Validates a possible PC value and returns true if an opcode can be at |
118 | // "pc". |
119 | virtual bool CodeAddressIsValid(lldb::addr_t pc) = 0; |
120 | |
121 | /// Some targets might use bits in a code address to indicate a mode switch. |
122 | /// ARM uses bit zero to signify a code address is thumb, so any ARM ABI |
123 | /// plug-ins would strip those bits. |
124 | /// @{ |
125 | virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) { return pc; } |
126 | virtual lldb::addr_t FixDataAddress(lldb::addr_t pc) { return pc; } |
127 | /// @} |
128 | |
129 | /// Use this method when you do not know, or do not care what kind of address |
130 | /// you are fixing. On platforms where there would be a difference between the |
131 | /// two types, it will pick the safest option. |
132 | /// |
133 | /// Its purpose is to signal that no specific choice was made and provide an |
134 | /// alternative to randomly picking FixCode/FixData address. Which could break |
135 | /// platforms where there is a difference (only Arm Thumb at this time). |
136 | virtual lldb::addr_t FixAnyAddress(lldb::addr_t pc) { |
137 | // On Arm Thumb fixing a code address zeroes the bottom bit, so FixData is |
138 | // the safe choice. On any other platform (so far) code and data addresses |
139 | // are fixed in the same way. |
140 | return FixDataAddress(pc); |
141 | } |
142 | |
143 | llvm::MCRegisterInfo &GetMCRegisterInfo() { return *m_mc_register_info_up; } |
144 | |
145 | virtual void |
146 | AugmentRegisterInfo(std::vector<DynamicRegisterInfo::Register> ®s) = 0; |
147 | |
148 | virtual bool GetPointerReturnRegister(const char *&name) { return false; } |
149 | |
150 | virtual uint64_t GetStackFrameSize() { return 512 * 1024; } |
151 | |
152 | static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch); |
153 | |
154 | protected: |
155 | ABI(lldb::ProcessSP process_sp, std::unique_ptr<llvm::MCRegisterInfo> info_up) |
156 | : m_process_wp(process_sp), m_mc_register_info_up(std::move(info_up)) { |
157 | assert(m_mc_register_info_up && "ABI must have MCRegisterInfo" ); |
158 | } |
159 | |
160 | /// Utility function to construct a MCRegisterInfo using the ArchSpec triple. |
161 | /// Plugins wishing to customize the construction can construct the |
162 | /// MCRegisterInfo themselves. |
163 | static std::unique_ptr<llvm::MCRegisterInfo> |
164 | MakeMCRegisterInfo(const ArchSpec &arch); |
165 | |
166 | lldb::ProcessWP m_process_wp; |
167 | std::unique_ptr<llvm::MCRegisterInfo> m_mc_register_info_up; |
168 | |
169 | virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc, lldb::addr_t mask) { |
170 | return pc; |
171 | } |
172 | |
173 | private: |
174 | ABI(const ABI &) = delete; |
175 | const ABI &operator=(const ABI &) = delete; |
176 | }; |
177 | |
178 | class RegInfoBasedABI : public ABI { |
179 | public: |
180 | void AugmentRegisterInfo( |
181 | std::vector<DynamicRegisterInfo::Register> ®s) override; |
182 | |
183 | protected: |
184 | using ABI::ABI; |
185 | |
186 | bool GetRegisterInfoByName(llvm::StringRef name, RegisterInfo &info); |
187 | |
188 | virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0; |
189 | }; |
190 | |
191 | class MCBasedABI : public ABI { |
192 | public: |
193 | void AugmentRegisterInfo( |
194 | std::vector<DynamicRegisterInfo::Register> ®s) override; |
195 | |
196 | /// If the register name is of the form "<from_prefix>[<number>]" then change |
197 | /// the name to "<to_prefix>[<number>]". Otherwise, leave the name unchanged. |
198 | static void MapRegisterName(std::string ®, llvm::StringRef from_prefix, |
199 | llvm::StringRef to_prefix); |
200 | |
201 | protected: |
202 | using ABI::ABI; |
203 | |
204 | /// Return eh_frame and dwarf numbers for the given register. |
205 | virtual std::pair<uint32_t, uint32_t> GetEHAndDWARFNums(llvm::StringRef reg); |
206 | |
207 | /// Return the generic number of the given register. |
208 | virtual uint32_t GetGenericNum(llvm::StringRef reg) = 0; |
209 | |
210 | /// For the given (capitalized) lldb register name, return the name of this |
211 | /// register in the MCRegisterInfo struct. |
212 | virtual std::string GetMCName(std::string reg) { return reg; } |
213 | }; |
214 | |
215 | } // namespace lldb_private |
216 | |
217 | #endif // LLDB_TARGET_ABI_H |
218 | |