Coverage Report

Created: 2023-11-11 10:31

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Target/RegisterNumber.cpp
Line
Count
Source (jump to first uncovered line)
1
//===-- RegisterNumber.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 "lldb/Target/RegisterNumber.h"
10
#include "lldb/Target/RegisterContext.h"
11
#include "lldb/Target/Thread.h"
12
13
using namespace lldb_private;
14
15
RegisterNumber::RegisterNumber(lldb_private::Thread &thread,
16
                               lldb::RegisterKind kind, uint32_t num)
17
1.26M
    : m_reg_ctx_sp(thread.GetRegisterContext()), m_regnum(num), m_kind(kind),
18
1.26M
      m_kind_regnum_map(), m_name("") {
19
1.26M
  if (m_reg_ctx_sp.get()) {
20
1.26M
    const lldb_private::RegisterInfo *reginfo =
21
1.26M
        m_reg_ctx_sp->GetRegisterInfoAtIndex(
22
1.26M
            GetAsKind(lldb::eRegisterKindLLDB));
23
1.26M
    if (reginfo && 
reginfo->name1.20M
) {
24
1.20M
      m_name = reginfo->name;
25
1.20M
    }
26
1.26M
  }
27
1.26M
}
28
29
63.5k
RegisterNumber::RegisterNumber() : m_reg_ctx_sp(), m_kind_regnum_map() {}
30
31
void RegisterNumber::init(lldb_private::Thread &thread, lldb::RegisterKind kind,
32
106
                          uint32_t num) {
33
106
  m_reg_ctx_sp = thread.GetRegisterContext();
34
106
  m_regnum = num;
35
106
  m_kind = kind;
36
106
  if (m_reg_ctx_sp.get()) {
37
106
    const lldb_private::RegisterInfo *reginfo =
38
106
        m_reg_ctx_sp->GetRegisterInfoAtIndex(
39
106
            GetAsKind(lldb::eRegisterKindLLDB));
40
106
    if (reginfo && reginfo->name) {
41
106
      m_name = reginfo->name;
42
106
    }
43
106
  }
44
106
}
45
46
106
const RegisterNumber &RegisterNumber::operator=(const RegisterNumber &rhs) {
47
106
  m_reg_ctx_sp = rhs.m_reg_ctx_sp;
48
106
  m_regnum = rhs.m_regnum;
49
106
  m_kind = rhs.m_kind;
50
106
  for (auto it : rhs.m_kind_regnum_map)
51
81
    m_kind_regnum_map[it.first] = it.second;
52
106
  m_name = rhs.m_name;
53
106
  return *this;
54
106
}
55
56
63.7k
bool RegisterNumber::operator==(RegisterNumber &rhs) {
57
63.7k
  if (IsValid() != rhs.IsValid())
58
0
    return false;
59
60
63.7k
  if (m_kind == rhs.m_kind) {
61
0
    return m_regnum == rhs.m_regnum;
62
0
  }
63
64
63.7k
  uint32_t rhs_regnum = rhs.GetAsKind(m_kind);
65
63.7k
  if (rhs_regnum != LLDB_INVALID_REGNUM) {
66
63.5k
    return m_regnum == rhs_regnum;
67
63.5k
  }
68
137
  uint32_t lhs_regnum = GetAsKind(rhs.m_kind);
69
137
  { return lhs_regnum == rhs.m_regnum; }
70
0
  return false;
71
63.7k
}
72
73
22
bool RegisterNumber::operator!=(RegisterNumber &rhs) { return !(*this == rhs); }
74
75
263k
bool RegisterNumber::IsValid() const {
76
263k
  return m_reg_ctx_sp.get() && 
m_kind != lldb::kNumRegisterKinds254k
&&
77
263k
         
m_regnum != 254k
LLDB_INVALID_REGNUM254k
;
78
263k
}
79
80
4.95M
uint32_t RegisterNumber::GetAsKind(lldb::RegisterKind kind) {
81
4.95M
  if (m_regnum == LLDB_INVALID_REGNUM)
82
0
    return LLDB_INVALID_REGNUM;
83
84
4.95M
  if (kind == m_kind)
85
3.40M
    return m_regnum;
86
87
1.54M
  Collection::iterator iter = m_kind_regnum_map.find(kind);
88
1.54M
  if (iter != m_kind_regnum_map.end()) {
89
653k
    return iter->second;
90
653k
  }
91
892k
  uint32_t output_regnum = LLDB_INVALID_REGNUM;
92
892k
  if (m_reg_ctx_sp &&
93
892k
      m_reg_ctx_sp->ConvertBetweenRegisterKinds(m_kind, m_regnum, kind,
94
892k
                                                output_regnum) &&
95
892k
      
output_regnum != 765k
LLDB_INVALID_REGNUM765k
) {
96
765k
    m_kind_regnum_map[kind] = output_regnum;
97
765k
  }
98
892k
  return output_regnum;
99
1.54M
}
100
101
244k
uint32_t RegisterNumber::GetRegisterNumber() const { return m_regnum; }
102
103
244k
lldb::RegisterKind RegisterNumber::GetRegisterKind() const { return m_kind; }
104
105
1.52M
const char *RegisterNumber::GetName() { return m_name; }