Coverage Report

Created: 2022-01-22 13:19

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- UnwindAssembly-x86.cpp --------------------------------------------===//
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
#include "UnwindAssembly-x86.h"
10
#include "x86AssemblyInspectionEngine.h"
11
12
#include "llvm-c/Disassembler.h"
13
#include "llvm/ADT/STLExtras.h"
14
#include "llvm/Support/TargetSelect.h"
15
16
#include "lldb/Core/Address.h"
17
#include "lldb/Core/PluginManager.h"
18
#include "lldb/Symbol/UnwindPlan.h"
19
#include "lldb/Target/ABI.h"
20
#include "lldb/Target/ExecutionContext.h"
21
#include "lldb/Target/Process.h"
22
#include "lldb/Target/RegisterContext.h"
23
#include "lldb/Target/RegisterNumber.h"
24
#include "lldb/Target/Target.h"
25
#include "lldb/Target/Thread.h"
26
#include "lldb/Target/UnwindAssembly.h"
27
#include "lldb/Utility/ArchSpec.h"
28
#include "lldb/Utility/Status.h"
29
30
using namespace lldb;
31
using namespace lldb_private;
32
33
LLDB_PLUGIN_DEFINE_ADV(UnwindAssembly_x86, UnwindAssemblyX86)
34
35
//  UnwindAssemblyParser_x86 method definitions
36
37
UnwindAssembly_x86::UnwindAssembly_x86(const ArchSpec &arch)
38
    : lldb_private::UnwindAssembly(arch),
39
21.0k
      m_assembly_inspection_engine(new x86AssemblyInspectionEngine(arch)) {}
40
41
21.0k
UnwindAssembly_x86::~UnwindAssembly_x86() {
42
21.0k
  delete m_assembly_inspection_engine;
43
21.0k
}
44
45
bool UnwindAssembly_x86::GetNonCallSiteUnwindPlanFromAssembly(
46
10.9k
    AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
47
10.9k
  if (!func.GetBaseAddress().IsValid() || func.GetByteSize() == 0)
48
0
    return false;
49
10.9k
  if (m_assembly_inspection_engine == nullptr)
50
0
    return false;
51
10.9k
  ProcessSP process_sp(thread.GetProcess());
52
10.9k
  if (process_sp.get() == nullptr)
53
0
    return false;
54
10.9k
  std::vector<uint8_t> function_text(func.GetByteSize());
55
10.9k
  Status error;
56
10.9k
  if (process_sp->GetTarget().ReadMemory(
57
10.9k
          func.GetBaseAddress(), function_text.data(), func.GetByteSize(),
58
10.9k
          error) == func.GetByteSize()) {
59
10.8k
    RegisterContextSP reg_ctx(thread.GetRegisterContext());
60
10.8k
    m_assembly_inspection_engine->Initialize(reg_ctx);
61
10.8k
    return m_assembly_inspection_engine->GetNonCallSiteUnwindPlanFromAssembly(
62
10.8k
        function_text.data(), func.GetByteSize(), func, unwind_plan);
63
10.8k
  }
64
23
  return false;
65
10.9k
}
66
67
bool UnwindAssembly_x86::AugmentUnwindPlanFromCallSite(
68
20
    AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
69
20
  bool do_augment_unwindplan = true;
70
71
20
  UnwindPlan::RowSP first_row = unwind_plan.GetRowForFunctionOffset(0);
72
20
  UnwindPlan::RowSP last_row = unwind_plan.GetRowForFunctionOffset(-1);
73
74
20
  int wordsize = 8;
75
20
  ProcessSP process_sp(thread.GetProcess());
76
20
  if (process_sp.get() == nullptr)
77
0
    return false;
78
79
20
  wordsize = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
80
81
20
  RegisterNumber sp_regnum(thread, eRegisterKindGeneric,
82
20
                           LLDB_REGNUM_GENERIC_SP);
83
20
  RegisterNumber pc_regnum(thread, eRegisterKindGeneric,
84
20
                           LLDB_REGNUM_GENERIC_PC);
85
86
  // Does this UnwindPlan describe the prologue?  I want to see that the CFA is
87
  // set in terms of the stack pointer plus an offset, and I want to see that
88
  // rip is retrieved at the CFA-wordsize. If there is no description of the
89
  // prologue, don't try to augment this eh_frame unwinder code, fall back to
90
  // assembly parsing instead.
91
92
20
  if (first_row->GetCFAValue().GetValueType() !=
93
20
          UnwindPlan::Row::FAValue::isRegisterPlusOffset ||
94
20
      RegisterNumber(thread, unwind_plan.GetRegisterKind(),
95
20
                     first_row->GetCFAValue().GetRegisterNumber()) !=
96
20
          sp_regnum ||
97
20
      first_row->GetCFAValue().GetOffset() != wordsize) {
98
1
    return false;
99
1
  }
100
19
  UnwindPlan::Row::RegisterLocation first_row_pc_loc;
101
19
  if (!first_row->GetRegisterInfo(
102
19
          pc_regnum.GetAsKind(unwind_plan.GetRegisterKind()),
103
19
          first_row_pc_loc) ||
104
19
      !first_row_pc_loc.IsAtCFAPlusOffset() ||
105
19
      
first_row_pc_loc.GetOffset() != -wordsize18
) {
106
1
    return false;
107
1
  }
108
109
  // It looks like the prologue is described. Is the epilogue described?  If it
110
  // is, no need to do any augmentation.
111
112
18
  if (first_row != last_row &&
113
18
      
first_row->GetOffset() != last_row->GetOffset()15
) {
114
    // The first & last row have the same CFA register and the same CFA offset
115
    // value and the CFA register is esp/rsp (the stack pointer).
116
117
    // We're checking that both of them have an unwind rule like "CFA=esp+4" or
118
    // CFA+rsp+8".
119
120
15
    if (first_row->GetCFAValue().GetValueType() ==
121
15
            last_row->GetCFAValue().GetValueType() &&
122
15
        first_row->GetCFAValue().GetRegisterNumber() ==
123
15
            last_row->GetCFAValue().GetRegisterNumber() &&
124
15
        first_row->GetCFAValue().GetOffset() ==
125
10
            last_row->GetCFAValue().GetOffset()) {
126
      // Get the register locations for eip/rip from the first & last rows. Are
127
      // they both CFA plus an offset?  Is it the same offset?
128
129
10
      UnwindPlan::Row::RegisterLocation last_row_pc_loc;
130
10
      if (last_row->GetRegisterInfo(
131
10
              pc_regnum.GetAsKind(unwind_plan.GetRegisterKind()),
132
10
              last_row_pc_loc)) {
133
10
        if (last_row_pc_loc.IsAtCFAPlusOffset() &&
134
10
            first_row_pc_loc.GetOffset() == last_row_pc_loc.GetOffset()) {
135
136
          // One last sanity check:  Is the unwind rule for getting the caller
137
          // pc value "deref the CFA-4" or "deref the CFA-8"?
138
139
          // If so, we have an UnwindPlan that already describes the epilogue
140
          // and we don't need to modify it at all.
141
142
10
          if (first_row_pc_loc.GetOffset() == -wordsize) {
143
10
            return true;
144
10
          }
145
10
        }
146
10
      }
147
10
    }
148
15
  }
149
150
8
  if (do_augment_unwindplan) {
151
8
    if (!func.GetBaseAddress().IsValid() || func.GetByteSize() == 0)
152
0
      return false;
153
8
    if (m_assembly_inspection_engine == nullptr)
154
0
      return false;
155
8
    std::vector<uint8_t> function_text(func.GetByteSize());
156
8
    Status error;
157
8
    if (process_sp->GetTarget().ReadMemory(
158
8
            func.GetBaseAddress(), function_text.data(), func.GetByteSize(),
159
8
            error) == func.GetByteSize()) {
160
8
      RegisterContextSP reg_ctx(thread.GetRegisterContext());
161
8
      m_assembly_inspection_engine->Initialize(reg_ctx);
162
8
      return m_assembly_inspection_engine->AugmentUnwindPlanFromCallSite(
163
8
          function_text.data(), func.GetByteSize(), func, unwind_plan, reg_ctx);
164
8
    }
165
8
  }
166
167
0
  return false;
168
8
}
169
170
bool UnwindAssembly_x86::GetFastUnwindPlan(AddressRange &func, Thread &thread,
171
10.0k
                                           UnwindPlan &unwind_plan) {
172
  // if prologue is
173
  //   55     pushl %ebp
174
  //   89 e5  movl %esp, %ebp
175
  //  or
176
  //   55        pushq %rbp
177
  //   48 89 e5  movq %rsp, %rbp
178
179
  // We should pull in the ABI architecture default unwind plan and return that
180
181
10.0k
  llvm::SmallVector<uint8_t, 4> opcode_data;
182
183
10.0k
  ProcessSP process_sp = thread.GetProcess();
184
10.0k
  if (process_sp) {
185
10.0k
    Target &target(process_sp->GetTarget());
186
10.0k
    Status error;
187
10.0k
    if (target.ReadMemory(func.GetBaseAddress(), opcode_data.data(), 4,
188
10.0k
                          error) == 4) {
189
10.0k
      uint8_t i386_push_mov[] = {0x55, 0x89, 0xe5};
190
10.0k
      uint8_t x86_64_push_mov[] = {0x55, 0x48, 0x89, 0xe5};
191
192
10.0k
      if (memcmp(opcode_data.data(), i386_push_mov, sizeof(i386_push_mov)) ==
193
10.0k
              0 ||
194
10.0k
          memcmp(opcode_data.data(), x86_64_push_mov,
195
10.0k
                 sizeof(x86_64_push_mov)) == 0) {
196
7.57k
        ABISP abi_sp = process_sp->GetABI();
197
7.57k
        if (abi_sp) {
198
7.57k
          return abi_sp->CreateDefaultUnwindPlan(unwind_plan);
199
7.57k
        }
200
7.57k
      }
201
10.0k
    }
202
10.0k
  }
203
2.50k
  return false;
204
10.0k
}
205
206
bool UnwindAssembly_x86::FirstNonPrologueInsn(
207
    AddressRange &func, const ExecutionContext &exe_ctx,
208
0
    Address &first_non_prologue_insn) {
209
210
0
  if (!func.GetBaseAddress().IsValid())
211
0
    return false;
212
213
0
  Target *target = exe_ctx.GetTargetPtr();
214
0
  if (target == nullptr)
215
0
    return false;
216
217
0
  if (m_assembly_inspection_engine == nullptr)
218
0
    return false;
219
220
0
  std::vector<uint8_t> function_text(func.GetByteSize());
221
0
  Status error;
222
0
  if (target->ReadMemory(func.GetBaseAddress(), function_text.data(),
223
0
                         func.GetByteSize(), error) == func.GetByteSize()) {
224
0
    size_t offset;
225
0
    if (m_assembly_inspection_engine->FindFirstNonPrologueInstruction(
226
0
            function_text.data(), func.GetByteSize(), offset)) {
227
0
      first_non_prologue_insn = func.GetBaseAddress();
228
0
      first_non_prologue_insn.Slide(offset);
229
0
    }
230
0
    return true;
231
0
  }
232
0
  return false;
233
0
}
234
235
21.0k
UnwindAssembly *UnwindAssembly_x86::CreateInstance(const ArchSpec &arch) {
236
21.0k
  const llvm::Triple::ArchType cpu = arch.GetMachine();
237
21.0k
  if (cpu == llvm::Triple::x86 || 
cpu == llvm::Triple::x86_6420.9k
)
238
21.0k
    return new UnwindAssembly_x86(arch);
239
0
  return nullptr;
240
21.0k
}
241
242
3.44k
void UnwindAssembly_x86::Initialize() {
243
3.44k
  PluginManager::RegisterPlugin(GetPluginNameStatic(),
244
3.44k
                                GetPluginDescriptionStatic(), CreateInstance);
245
3.44k
}
246
247
3.43k
void UnwindAssembly_x86::Terminate() {
248
3.43k
  PluginManager::UnregisterPlugin(CreateInstance);
249
3.43k
}
250
251
3.44k
llvm::StringRef UnwindAssembly_x86::GetPluginDescriptionStatic() {
252
3.44k
  return "i386 and x86_64 assembly language profiler plugin.";
253
3.44k
}