Coverage Report

Created: 2022-01-18 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Core/Architecture.h
Line
Count
Source (jump to first uncovered line)
1
//===-- Architecture.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_CORE_ARCHITECTURE_H
10
#define LLDB_CORE_ARCHITECTURE_H
11
12
#include "lldb/Core/PluginInterface.h"
13
#include "lldb/Target/MemoryTagManager.h"
14
15
namespace lldb_private {
16
17
class Architecture : public PluginInterface {
18
public:
19
  /// This is currently intended to handle cases where a
20
  /// program stops at an instruction that won't get executed and it
21
  /// allows the stop reason, like "breakpoint hit", to be replaced
22
  /// with a different stop reason like "no stop reason".
23
  ///
24
  /// This is specifically used for ARM in Thumb code when we stop in
25
  /// an IT instruction (if/then/else) where the instruction won't get
26
  /// executed and therefore it wouldn't be correct to show the program
27
  /// stopped at the current PC. The code is generic and applies to all
28
  /// ARM CPUs.
29
  virtual void OverrideStopInfo(Thread &thread) const = 0;
30
31
  /// This method is used to get the number of bytes that should be
32
  /// skipped, from function start address, to reach the first
33
  /// instruction after the prologue. If overrode, it must return
34
  /// non-zero only if the current address matches one of the known
35
  /// function entry points.
36
  ///
37
  /// This method is called only if the standard platform-independent
38
  /// code fails to get the number of bytes to skip, giving the plugin
39
  /// a chance to try to find the missing info.
40
  ///
41
  /// This is specifically used for PPC64, where functions may have
42
  /// more than one entry point, global and local, so both should
43
  /// be compared with current address, in order to find out the
44
  /// number of bytes that should be skipped, in case we are stopped
45
  /// at either function entry point.
46
0
  virtual size_t GetBytesToSkip(Symbol &func, const Address &curr_addr) const {
47
0
    return 0;
48
0
  }
49
50
  /// Adjust function breakpoint address, if needed. In some cases,
51
  /// the function start address is not the right place to set the
52
  /// breakpoint, specially in functions with multiple entry points.
53
  ///
54
  /// This is specifically used for PPC64, for functions that have
55
  /// both a global and a local entry point. In this case, the
56
  /// breakpoint is adjusted to the first function address reached
57
  /// by both entry points.
58
  virtual void AdjustBreakpointAddress(const Symbol &func,
59
0
                                       Address &addr) const {}
60
61
62
  /// Get \a load_addr as a callable code load address for this target
63
  ///
64
  /// Take \a load_addr and potentially add any address bits that are
65
  /// needed to make the address callable. For ARM this can set bit
66
  /// zero (if it already isn't) if \a load_addr is a thumb function.
67
  /// If \a addr_class is set to AddressClass::eInvalid, then the address
68
  /// adjustment will always happen. If it is set to an address class
69
  /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
70
  /// returned.
71
  virtual lldb::addr_t GetCallableLoadAddress(
72
0
      lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
73
0
    return addr;
74
0
  }
75
76
  /// Get \a load_addr as an opcode for this target.
77
  ///
78
  /// Take \a load_addr and potentially strip any address bits that are
79
  /// needed to make the address point to an opcode. For ARM this can
80
  /// clear bit zero (if it already isn't) if \a load_addr is a
81
  /// thumb function and load_addr is in code.
82
  /// If \a addr_class is set to AddressClass::eInvalid, then the address
83
  /// adjustment will always happen. If it is set to an address class
84
  /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
85
  /// returned.
86
87
  virtual lldb::addr_t GetOpcodeLoadAddress(
88
79
      lldb::addr_t addr, AddressClass addr_class = AddressClass::eInvalid) const {
89
79
    return addr;
90
79
  }
91
92
  // Get load_addr as breakable load address for this target. Take a addr and
93
  // check if for any reason there is a better address than this to put a
94
  // breakpoint on. If there is then return that address. For MIPS, if
95
  // instruction at addr is a delay slot instruction then this method will find
96
  // the address of its previous instruction and return that address.
97
  virtual lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr,
98
13
                                               Target &target) const {
99
13
    return addr;
100
13
  }
101
102
  // Returns a pointer to an object that can manage memory tags for this
103
  // Architecture E.g. masking out tags, unpacking tag streams etc. Returns
104
  // nullptr if the architecture does not have a memory tagging extension.
105
  //
106
  // The return pointer being valid does not mean that the current process has
107
  // memory tagging enabled, just that a tagging technology exists for this
108
  // architecture.
109
0
  virtual const MemoryTagManager *GetMemoryTagManager() const {
110
0
    return nullptr;
111
0
  }
112
};
113
114
} // namespace lldb_private
115
116
#endif // LLDB_CORE_ARCHITECTURE_H