1 //===-- Architecture.h ------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLDB_CORE_ARCHITECTURE_H
11 #define LLDB_CORE_ARCHITECTURE_H
13 #include "lldb/Core/PluginInterface.h"
15 namespace lldb_private {
17 class Architecture : public PluginInterface {
19 Architecture() = default;
20 virtual ~Architecture() = default;
22 //------------------------------------------------------------------
23 /// This is currently intended to handle cases where a
24 /// program stops at an instruction that won't get executed and it
25 /// allows the stop reason, like "breakpoint hit", to be replaced
26 /// with a different stop reason like "no stop reason".
28 /// This is specifically used for ARM in Thumb code when we stop in
29 /// an IT instruction (if/then/else) where the instruction won't get
30 /// executed and therefore it wouldn't be correct to show the program
31 /// stopped at the current PC. The code is generic and applies to all
33 //------------------------------------------------------------------
34 virtual void OverrideStopInfo(Thread &thread) const = 0;
36 //------------------------------------------------------------------
37 /// This method is used to get the number of bytes that should be
38 /// skipped, from function start address, to reach the first
39 /// instruction after the prologue. If overrode, it must return
40 /// non-zero only if the current address matches one of the known
41 /// function entry points.
43 /// This method is called only if the standard platform-independent
44 /// code fails to get the number of bytes to skip, giving the plugin
45 /// a chance to try to find the missing info.
47 /// This is specifically used for PPC64, where functions may have
48 /// more than one entry point, global and local, so both should
49 /// be compared with current address, in order to find out the
50 /// number of bytes that should be skipped, in case we are stopped
51 /// at either function entry point.
52 //------------------------------------------------------------------
53 virtual size_t GetBytesToSkip(Symbol &func, const Address &curr_addr) const {
57 //------------------------------------------------------------------
58 /// Adjust function breakpoint address, if needed. In some cases,
59 /// the function start address is not the right place to set the
60 /// breakpoint, specially in functions with multiple entry points.
62 /// This is specifically used for PPC64, for functions that have
63 /// both a global and a local entry point. In this case, the
64 /// breakpoint is adjusted to the first function address reached
65 /// by both entry points.
66 //------------------------------------------------------------------
67 virtual void AdjustBreakpointAddress(const Symbol &func,
68 Address &addr) const {}
71 //------------------------------------------------------------------
72 /// Get \a load_addr as a callable code load address for this target
74 /// Take \a load_addr and potentially add any address bits that are
75 /// needed to make the address callable. For ARM this can set bit
76 /// zero (if it already isn't) if \a load_addr is a thumb function.
77 /// If \a addr_class is set to AddressClass::eInvalid, then the address
78 /// adjustment will always happen. If it is set to an address class
79 /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
81 //------------------------------------------------------------------
82 virtual lldb::addr_t GetCallableLoadAddress(
83 lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
87 //------------------------------------------------------------------
88 /// Get \a load_addr as an opcode for this target.
90 /// Take \a load_addr and potentially strip any address bits that are
91 /// needed to make the address point to an opcode. For ARM this can
92 /// clear bit zero (if it already isn't) if \a load_addr is a
93 /// thumb function and load_addr is in code.
94 /// If \a addr_class is set to AddressClass::eInvalid, then the address
95 /// adjustment will always happen. If it is set to an address class
96 /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
98 //------------------------------------------------------------------
100 virtual lldb::addr_t GetOpcodeLoadAddress(
101 lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
105 // Get load_addr as breakable load address for this target. Take a addr and
106 // check if for any reason there is a better address than this to put a
107 // breakpoint on. If there is then return that address. For MIPS, if
108 // instruction at addr is a delay slot instruction then this method will find
109 // the address of its previous instruction and return that address.
110 virtual lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr,
111 Target &target) const {
116 Architecture(const Architecture &) = delete;
117 void operator=(const Architecture &) = delete;
120 } // namespace lldb_private
122 #endif // LLDB_CORE_ARCHITECTURE_H