File: | tools/lldb/include/lldb/Core/FormatEntity.h |
Warning: | line 113, column 12 Excessive padding in 'struct lldb_private::FormatEntity::Entry::Definition' (11 padding bytes, where 3 is optimal). Optimal fields order: name, string, data, children, type, format_type, num_children, keep_separator, consider reordering the fields or adding explicit padding members |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- FormatEntity.h ------------------------------------------*- C++ -*-===// |
2 | // |
3 | // The LLVM Compiler Infrastructure |
4 | // |
5 | // This file is distributed under the University of Illinois Open Source |
6 | // License. See LICENSE.TXT for details. |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef liblldb_FormatEntity_h_ |
11 | #define liblldb_FormatEntity_h_ |
12 | |
13 | #include "lldb/Utility/FileSpec.h" // for FileSpec |
14 | #include "lldb/Utility/Status.h" |
15 | #include "lldb/lldb-enumerations.h" // for Format::eFormatDefault, Format |
16 | #include "lldb/lldb-types.h" // for addr_t |
17 | #include <algorithm> // for min |
18 | #include <stddef.h> // for size_t |
19 | #include <stdint.h> // for uint32_t, uint64_t |
20 | |
21 | #include <string> |
22 | #include <vector> |
23 | |
24 | namespace lldb_private { |
25 | class Address; |
26 | } |
27 | namespace lldb_private { |
28 | class ExecutionContext; |
29 | } |
30 | namespace lldb_private { |
31 | class Stream; |
32 | } |
33 | namespace lldb_private { |
34 | class StringList; |
35 | } |
36 | namespace lldb_private { |
37 | class SymbolContext; |
38 | } |
39 | namespace lldb_private { |
40 | class ValueObject; |
41 | } |
42 | namespace llvm { |
43 | class StringRef; |
44 | } |
45 | |
46 | namespace lldb_private { |
47 | class FormatEntity { |
48 | public: |
49 | struct Entry { |
50 | enum class Type { |
51 | Invalid, |
52 | ParentNumber, |
53 | ParentString, |
54 | InsertString, |
55 | Root, |
56 | String, |
57 | Scope, |
58 | Variable, |
59 | VariableSynthetic, |
60 | ScriptVariable, |
61 | ScriptVariableSynthetic, |
62 | AddressLoad, |
63 | AddressFile, |
64 | AddressLoadOrFile, |
65 | ProcessID, |
66 | ProcessFile, |
67 | ScriptProcess, |
68 | ThreadID, |
69 | ThreadProtocolID, |
70 | ThreadIndexID, |
71 | ThreadName, |
72 | ThreadQueue, |
73 | ThreadStopReason, |
74 | ThreadReturnValue, |
75 | ThreadCompletedExpression, |
76 | ScriptThread, |
77 | ThreadInfo, |
78 | TargetArch, |
79 | ScriptTarget, |
80 | ModuleFile, |
81 | File, |
82 | Lang, |
83 | FrameIndex, |
84 | FrameNoDebug, |
85 | FrameRegisterPC, |
86 | FrameRegisterSP, |
87 | FrameRegisterFP, |
88 | FrameRegisterFlags, |
89 | FrameRegisterByName, |
90 | ScriptFrame, |
91 | FunctionID, |
92 | FunctionDidChange, |
93 | FunctionInitialFunction, |
94 | FunctionName, |
95 | FunctionNameWithArgs, |
96 | FunctionNameNoArgs, |
97 | FunctionAddrOffset, |
98 | FunctionAddrOffsetConcrete, |
99 | FunctionLineOffset, |
100 | FunctionPCOffset, |
101 | FunctionInitial, |
102 | FunctionChanged, |
103 | FunctionIsOptimized, |
104 | LineEntryFile, |
105 | LineEntryLineNumber, |
106 | LineEntryStartAddress, |
107 | LineEntryEndAddress, |
108 | CurrentPCArrow |
109 | }; |
110 | |
111 | enum FormatType { None, UInt32, UInt64, CString }; |
112 | |
113 | struct Definition { |
Excessive padding in 'struct lldb_private::FormatEntity::Entry::Definition' (11 padding bytes, where 3 is optimal).
Optimal fields order:
name,
string,
data,
children,
type,
format_type,
num_children,
keep_separator,
consider reordering the fields or adding explicit padding members | |
114 | const char *name; |
115 | const char *string; // Insert this exact string into the output |
116 | Entry::Type type; |
117 | FormatType format_type; // uint32_t, uint64_t, cstr, or anything that can |
118 | // be formatted by printf or lldb::Format |
119 | uint64_t data; |
120 | uint32_t num_children; |
121 | Definition *children; // An array of "num_children" Definition entries, |
122 | bool keep_separator; |
123 | }; |
124 | |
125 | Entry(Type t = Type::Invalid, const char *s = nullptr, |
126 | const char *f = nullptr) |
127 | : string(s ? s : ""), printf_format(f ? f : ""), children(), |
128 | definition(nullptr), type(t), fmt(lldb::eFormatDefault), number(0), |
129 | deref(false) {} |
130 | |
131 | Entry(llvm::StringRef s); |
132 | Entry(char ch); |
133 | |
134 | void AppendChar(char ch); |
135 | |
136 | void AppendText(const llvm::StringRef &s); |
137 | |
138 | void AppendText(const char *cstr); |
139 | |
140 | void AppendEntry(const Entry &&entry) { children.push_back(entry); } |
141 | |
142 | void Clear() { |
143 | string.clear(); |
144 | printf_format.clear(); |
145 | children.clear(); |
146 | definition = nullptr; |
147 | type = Type::Invalid; |
148 | fmt = lldb::eFormatDefault; |
149 | number = 0; |
150 | deref = false; |
151 | } |
152 | |
153 | static const char *TypeToCString(Type t); |
154 | |
155 | void Dump(Stream &s, int depth = 0) const; |
156 | |
157 | bool operator==(const Entry &rhs) const { |
158 | if (string != rhs.string) |
159 | return false; |
160 | if (printf_format != rhs.printf_format) |
161 | return false; |
162 | const size_t n = children.size(); |
163 | const size_t m = rhs.children.size(); |
164 | for (size_t i = 0; i < std::min<size_t>(n, m); ++i) { |
165 | if (!(children[i] == rhs.children[i])) |
166 | return false; |
167 | } |
168 | if (children != rhs.children) |
169 | return false; |
170 | if (definition != rhs.definition) |
171 | return false; |
172 | if (type != rhs.type) |
173 | return false; |
174 | if (fmt != rhs.fmt) |
175 | return false; |
176 | if (deref != rhs.deref) |
177 | return false; |
178 | return true; |
179 | } |
180 | |
181 | std::string string; |
182 | std::string printf_format; |
183 | std::vector<Entry> children; |
184 | Definition *definition; |
185 | Type type; |
186 | lldb::Format fmt; |
187 | lldb::addr_t number; |
188 | bool deref; |
189 | }; |
190 | |
191 | static bool Format(const Entry &entry, Stream &s, const SymbolContext *sc, |
192 | const ExecutionContext *exe_ctx, const Address *addr, |
193 | ValueObject *valobj, bool function_changed, |
194 | bool initial_function); |
195 | |
196 | static bool FormatStringRef(const llvm::StringRef &format, Stream &s, |
197 | const SymbolContext *sc, |
198 | const ExecutionContext *exe_ctx, |
199 | const Address *addr, ValueObject *valobj, |
200 | bool function_changed, bool initial_function); |
201 | |
202 | static bool FormatCString(const char *format, Stream &s, |
203 | const SymbolContext *sc, |
204 | const ExecutionContext *exe_ctx, |
205 | const Address *addr, ValueObject *valobj, |
206 | bool function_changed, bool initial_function); |
207 | |
208 | static Status Parse(const llvm::StringRef &format, Entry &entry); |
209 | |
210 | static Status ExtractVariableInfo(llvm::StringRef &format_str, |
211 | llvm::StringRef &variable_name, |
212 | llvm::StringRef &variable_format); |
213 | |
214 | static size_t AutoComplete(llvm::StringRef s, int match_start_point, |
215 | int max_return_elements, bool &word_complete, |
216 | StringList &matches); |
217 | |
218 | //---------------------------------------------------------------------- |
219 | // Format the current elements into the stream \a s. |
220 | // |
221 | // The root element will be stripped off and the format str passed in |
222 | // will be either an empty string (print a description of this object), |
223 | // or contain a . separated series like a domain name that identifies |
224 | // further sub elements to display. |
225 | //---------------------------------------------------------------------- |
226 | static bool FormatFileSpec(const FileSpec &file, Stream &s, |
227 | llvm::StringRef elements, |
228 | llvm::StringRef element_format); |
229 | |
230 | protected: |
231 | static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry, |
232 | uint32_t depth); |
233 | }; |
234 | } // namespace lldb_private |
235 | |
236 | #endif // liblldb_FormatEntity_h_ |