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
| //===-- Architecture.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 LLDB_CORE_ARCHITECTURE_H
#define LLDB_CORE_ARCHITECTURE_H
#include "lldb/Core/PluginInterface.h"
namespace lldb_private {
class Architecture : public PluginInterface {
public:
Architecture() = default;
~Architecture() override = default;
/// This is currently intended to handle cases where a
/// program stops at an instruction that won't get executed and it
/// allows the stop reason, like "breakpoint hit", to be replaced
/// with a different stop reason like "no stop reason".
///
/// This is specifically used for ARM in Thumb code when we stop in
/// an IT instruction (if/then/else) where the instruction won't get
/// executed and therefore it wouldn't be correct to show the program
/// stopped at the current PC. The code is generic and applies to all
/// ARM CPUs.
virtual void OverrideStopInfo(Thread &thread) const = 0;
/// This method is used to get the number of bytes that should be
/// skipped, from function start address, to reach the first
/// instruction after the prologue. If overrode, it must return
/// non-zero only if the current address matches one of the known
/// function entry points.
///
/// This method is called only if the standard platform-independent
/// code fails to get the number of bytes to skip, giving the plugin
/// a chance to try to find the missing info.
///
/// This is specifically used for PPC64, where functions may have
/// more than one entry point, global and local, so both should
/// be compared with current address, in order to find out the
/// number of bytes that should be skipped, in case we are stopped
/// at either function entry point.
virtual size_t GetBytesToSkip(Symbol &func, const Address &curr_addr) const {
return 0;
}
/// Adjust function breakpoint address, if needed. In some cases,
/// the function start address is not the right place to set the
/// breakpoint, specially in functions with multiple entry points.
///
/// This is specifically used for PPC64, for functions that have
/// both a global and a local entry point. In this case, the
/// breakpoint is adjusted to the first function address reached
/// by both entry points.
virtual void AdjustBreakpointAddress(const Symbol &func,
Address &addr) const {}
/// Get \a load_addr as a callable code load address for this target
///
/// Take \a load_addr and potentially add any address bits that are
/// needed to make the address callable. For ARM this can set bit
/// zero (if it already isn't) if \a load_addr is a thumb function.
/// If \a addr_class is set to AddressClass::eInvalid, then the address
/// adjustment will always happen. If it is set to an address class
/// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
/// returned.
virtual lldb::addr_t GetCallableLoadAddress(
lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
return addr;
}
/// Get \a load_addr as an opcode for this target.
///
/// Take \a load_addr and potentially strip any address bits that are
/// needed to make the address point to an opcode. For ARM this can
/// clear bit zero (if it already isn't) if \a load_addr is a
/// thumb function and load_addr is in code.
/// If \a addr_class is set to AddressClass::eInvalid, then the address
/// adjustment will always happen. If it is set to an address class
/// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
/// returned.
virtual lldb::addr_t GetOpcodeLoadAddress(
lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
return addr;
}
// Get load_addr as breakable load address for this target. Take a addr and
// check if for any reason there is a better address than this to put a
// breakpoint on. If there is then return that address. For MIPS, if
// instruction at addr is a delay slot instruction then this method will find
// the address of its previous instruction and return that address.
virtual lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr,
Target &target) const {
return addr;
}
private:
Architecture(const Architecture &) = delete;
void operator=(const Architecture &) = delete;
};
} // namespace lldb_private
#endif // LLDB_CORE_ARCHITECTURE_H
|