blob: f1710f8c6ec20b2b4a124570d9c56b181918625f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
//===-- ThreadSpec.h --------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ThreadSpec_h_
#define liblldb_ThreadSpec_h_
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-private.h"
#include <string>
namespace lldb_private {
// Note: For now the thread spec has only fixed elements -
// Thread ID
// Thread Index
// Thread Name
// Thread Queue Name
//
// But if we need more generality, we can hang a key/value map off of this
// structure.
// That's why the thread matches spec test is done as a virtual method in
// Thread::MatchesSpec,
// since it is the native thread that would know how to interpret the keys.
// I was going to do the Queue Name this way out of sheer orneriness, but that
// seems a
// sufficiently general concept, so I put it in here on its own.
class ThreadSpec {
public:
ThreadSpec();
ThreadSpec(const ThreadSpec &rhs);
const ThreadSpec &operator=(const ThreadSpec &rhs);
static std::unique_ptr<ThreadSpec>
CreateFromStructuredData(const StructuredData::Dictionary &data_dict,
Status &error);
StructuredData::ObjectSP SerializeToStructuredData();
static const char *GetSerializationKey() { return "ThreadSpec"; }
void SetIndex(uint32_t index) { m_index = index; }
void SetTID(lldb::tid_t tid) { m_tid = tid; }
void SetName(llvm::StringRef name) { m_name = name; }
void SetQueueName(llvm::StringRef queue_name) { m_queue_name = queue_name; }
uint32_t GetIndex() const { return m_index; }
lldb::tid_t GetTID() const { return m_tid; }
const char *GetName() const;
const char *GetQueueName() const;
bool TIDMatches(lldb::tid_t thread_id) const {
if (m_tid == LLDB_INVALID_THREAD_ID || thread_id == LLDB_INVALID_THREAD_ID)
return true;
else
return thread_id == m_tid;
}
bool TIDMatches(Thread &thread) const;
bool IndexMatches(uint32_t index) const {
if (m_index == UINT32_MAX || index == UINT32_MAX)
return true;
else
return index == m_index;
}
bool IndexMatches(Thread &thread) const;
bool NameMatches(const char *name) const {
if (m_name.empty())
return true;
else if (name == nullptr)
return false;
else
return m_name == name;
}
bool NameMatches(Thread &thread) const;
bool QueueNameMatches(const char *queue_name) const {
if (m_queue_name.empty())
return true;
else if (queue_name == nullptr)
return false;
else
return m_queue_name == queue_name;
}
bool QueueNameMatches(Thread &thread) const;
bool ThreadPassesBasicTests(Thread &thread) const;
bool HasSpecification() const;
void GetDescription(Stream *s, lldb::DescriptionLevel level) const;
private:
enum class OptionNames {
ThreadIndex = 0,
ThreadID,
ThreadName,
QueueName,
LastOptionName
};
static const char *g_option_names[(size_t)OptionNames::LastOptionName];
static const char *GetKey(OptionNames enum_value) {
return g_option_names[(size_t) enum_value];
}
uint32_t m_index;
lldb::tid_t m_tid;
std::string m_name;
std::string m_queue_name;
};
} // namespace lldb_private
#endif // liblldb_ThreadSpec_h_
|
