Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h
Line
Count
Source (jump to first uncovered line)
1
//===-- UnwindAssemblyInstEmulation.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_SOURCE_PLUGINS_UNWINDASSEMBLY_INSTEMULATION_UNWINDASSEMBLYINSTEMULATION_H
10
#define LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_INSTEMULATION_UNWINDASSEMBLYINSTEMULATION_H
11
12
#include "lldb/Core/EmulateInstruction.h"
13
#include "lldb/Symbol/UnwindPlan.h"
14
#include "lldb/Target/UnwindAssembly.h"
15
#include "lldb/Utility/RegisterValue.h"
16
#include "lldb/lldb-private.h"
17
18
class UnwindAssemblyInstEmulation : public lldb_private::UnwindAssembly {
19
public:
20
30
  ~UnwindAssemblyInstEmulation() override = default;
21
22
  bool GetNonCallSiteUnwindPlanFromAssembly(
23
      lldb_private::AddressRange &func, lldb_private::Thread &thread,
24
      lldb_private::UnwindPlan &unwind_plan) override;
25
26
  bool
27
  GetNonCallSiteUnwindPlanFromAssembly(lldb_private::AddressRange &func,
28
                                       uint8_t *opcode_data, size_t opcode_size,
29
                                       lldb_private::UnwindPlan &unwind_plan);
30
31
  bool
32
  AugmentUnwindPlanFromCallSite(lldb_private::AddressRange &func,
33
                                lldb_private::Thread &thread,
34
                                lldb_private::UnwindPlan &unwind_plan) override;
35
36
  bool GetFastUnwindPlan(lldb_private::AddressRange &func,
37
                         lldb_private::Thread &thread,
38
                         lldb_private::UnwindPlan &unwind_plan) override;
39
40
  // thread may be NULL in which case we only use the Target (e.g. if this is
41
  // called pre-process-launch).
42
  bool
43
  FirstNonPrologueInsn(lldb_private::AddressRange &func,
44
                       const lldb_private::ExecutionContext &exe_ctx,
45
                       lldb_private::Address &first_non_prologue_insn) override;
46
47
  static lldb_private::UnwindAssembly *
48
  CreateInstance(const lldb_private::ArchSpec &arch);
49
50
  // PluginInterface protocol
51
  static void Initialize();
52
53
  static void Terminate();
54
55
3.44k
  static llvm::StringRef GetPluginNameStatic() { return "inst-emulation"; }
56
57
  static llvm::StringRef GetPluginDescriptionStatic();
58
59
0
  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
60
61
private:
62
  // Call CreateInstance to get an instance of this class
63
  UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch,
64
                              lldb_private::EmulateInstruction *inst_emulator)
65
      : UnwindAssembly(arch), m_inst_emulator_up(inst_emulator),
66
        m_range_ptr(nullptr), m_unwind_plan_ptr(nullptr), m_curr_row(),
67
        m_cfa_reg_info(), m_fp_is_cfa(false), m_register_values(),
68
        m_pushed_regs(), m_curr_row_modified(false),
69
30
        m_forward_branch_offset(0) {
70
30
    if (m_inst_emulator_up.get()) {
71
30
      m_inst_emulator_up->SetBaton(this);
72
30
      m_inst_emulator_up->SetCallbacks(ReadMemory, WriteMemory, ReadRegister,
73
30
                                       WriteRegister);
74
30
    }
75
30
  }
76
77
  static size_t
78
  ReadMemory(lldb_private::EmulateInstruction *instruction, void *baton,
79
             const lldb_private::EmulateInstruction::Context &context,
80
             lldb::addr_t addr, void *dst, size_t length);
81
82
  static size_t
83
  WriteMemory(lldb_private::EmulateInstruction *instruction, void *baton,
84
              const lldb_private::EmulateInstruction::Context &context,
85
              lldb::addr_t addr, const void *dst, size_t length);
86
87
  static bool ReadRegister(lldb_private::EmulateInstruction *instruction,
88
                           void *baton,
89
                           const lldb_private::RegisterInfo *reg_info,
90
                           lldb_private::RegisterValue &reg_value);
91
92
  static bool
93
  WriteRegister(lldb_private::EmulateInstruction *instruction, void *baton,
94
                const lldb_private::EmulateInstruction::Context &context,
95
                const lldb_private::RegisterInfo *reg_info,
96
                const lldb_private::RegisterValue &reg_value);
97
98
  //    size_t
99
  //    ReadMemory (lldb_private::EmulateInstruction *instruction,
100
  //                const lldb_private::EmulateInstruction::Context &context,
101
  //                lldb::addr_t addr,
102
  //                void *dst,
103
  //                size_t length);
104
105
  size_t WriteMemory(lldb_private::EmulateInstruction *instruction,
106
                     const lldb_private::EmulateInstruction::Context &context,
107
                     lldb::addr_t addr, const void *dst, size_t length);
108
109
  bool ReadRegister(lldb_private::EmulateInstruction *instruction,
110
                    const lldb_private::RegisterInfo *reg_info,
111
                    lldb_private::RegisterValue &reg_value);
112
113
  bool WriteRegister(lldb_private::EmulateInstruction *instruction,
114
                     const lldb_private::EmulateInstruction::Context &context,
115
                     const lldb_private::RegisterInfo *reg_info,
116
                     const lldb_private::RegisterValue &reg_value);
117
118
  static uint64_t
119
  MakeRegisterKindValuePair(const lldb_private::RegisterInfo &reg_info);
120
121
  void SetRegisterValue(const lldb_private::RegisterInfo &reg_info,
122
                        const lldb_private::RegisterValue &reg_value);
123
124
  bool GetRegisterValue(const lldb_private::RegisterInfo &reg_info,
125
                        lldb_private::RegisterValue &reg_value);
126
127
  std::unique_ptr<lldb_private::EmulateInstruction> m_inst_emulator_up;
128
  lldb_private::AddressRange *m_range_ptr;
129
  lldb_private::UnwindPlan *m_unwind_plan_ptr;
130
  lldb_private::UnwindPlan::RowSP m_curr_row;
131
  typedef std::map<uint64_t, uint64_t> PushedRegisterToAddrMap;
132
  uint64_t m_initial_sp;
133
  lldb_private::RegisterInfo m_cfa_reg_info;
134
  bool m_fp_is_cfa;
135
  typedef std::map<uint64_t, lldb_private::RegisterValue> RegisterValueMap;
136
  RegisterValueMap m_register_values;
137
  PushedRegisterToAddrMap m_pushed_regs;
138
139
  // While processing the instruction stream, we need to communicate some state
140
  // change
141
  // information up to the higher level loop that makes decisions about how to
142
  // push
143
  // the unwind instructions for the UnwindPlan we're constructing.
144
145
  // The instruction we're processing updated the UnwindPlan::Row contents
146
  bool m_curr_row_modified;
147
  // The instruction is branching forward with the given offset. 0 value means
148
  // no branching.
149
  uint32_t m_forward_branch_offset;
150
};
151
152
#endif // LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_INSTEMULATION_UNWINDASSEMBLYINSTEMULATION_H