Bug Summary

File:src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp
Warning:line 380, column 11
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ClangExpressionSourceCode.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/clang/include -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp
1//===-- ClangExpressionSourceCode.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 "ClangExpressionSourceCode.h"
10
11#include "clang/Basic/CharInfo.h"
12#include "clang/Basic/FileManager.h"
13#include "clang/Basic/SourceManager.h"
14#include "clang/Lex/Lexer.h"
15#include "llvm/ADT/StringRef.h"
16
17#include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
18#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
19#include "lldb/Symbol/Block.h"
20#include "lldb/Symbol/CompileUnit.h"
21#include "lldb/Symbol/DebugMacros.h"
22#include "lldb/Symbol/TypeSystem.h"
23#include "lldb/Symbol/VariableList.h"
24#include "lldb/Target/ExecutionContext.h"
25#include "lldb/Target/Language.h"
26#include "lldb/Target/Platform.h"
27#include "lldb/Target/StackFrame.h"
28#include "lldb/Target/Target.h"
29#include "lldb/Utility/StreamString.h"
30
31using namespace lldb_private;
32
33#define PREFIX_NAME"<lldb wrapper prefix>" "<lldb wrapper prefix>"
34#define SUFFIX_NAME"<lldb wrapper suffix>" "<lldb wrapper suffix>"
35
36const llvm::StringRef ClangExpressionSourceCode::g_prefix_file_name = PREFIX_NAME"<lldb wrapper prefix>";
37
38const char *ClangExpressionSourceCode::g_expression_prefix =
39"#line 1 \"" PREFIX_NAME"<lldb wrapper prefix>" R"("
40#ifndef offsetof
41#define offsetof(t, d) __builtin_offsetof(t, d)
42#endif
43#ifndef NULL
44#define NULL (__null)
45#endif
46#ifndef Nil
47#define Nil (__null)
48#endif
49#ifndef nil
50#define nil (__null)
51#endif
52#ifndef YES
53#define YES ((BOOL)1)
54#endif
55#ifndef NO
56#define NO ((BOOL)0)
57#endif
58typedef __INT8_TYPE__ int8_t;
59typedef __UINT8_TYPE__ uint8_t;
60typedef __INT16_TYPE__ int16_t;
61typedef __UINT16_TYPE__ uint16_t;
62typedef __INT32_TYPE__ int32_t;
63typedef __UINT32_TYPE__ uint32_t;
64typedef __INT64_TYPE__ int64_t;
65typedef __UINT64_TYPE__ uint64_t;
66typedef __INTPTR_TYPE__ intptr_t;
67typedef __UINTPTR_TYPE__ uintptr_t;
68typedef __SIZE_TYPE__ size_t;
69typedef __PTRDIFF_TYPE__ ptrdiff_t;
70typedef unsigned short unichar;
71extern "C"
72{
73 int printf(const char * __restrict, ...);
74}
75)";
76
77const char *ClangExpressionSourceCode::g_expression_suffix =
78 "\n;\n#line 1 \"" SUFFIX_NAME"<lldb wrapper suffix>" "\"\n";
79
80namespace {
81
82class AddMacroState {
83 enum State {
84 CURRENT_FILE_NOT_YET_PUSHED,
85 CURRENT_FILE_PUSHED,
86 CURRENT_FILE_POPPED
87 };
88
89public:
90 AddMacroState(const FileSpec &current_file, const uint32_t current_file_line)
91 : m_state(CURRENT_FILE_NOT_YET_PUSHED), m_current_file(current_file),
92 m_current_file_line(current_file_line) {}
93
94 void StartFile(const FileSpec &file) {
95 m_file_stack.push_back(file);
96 if (file == m_current_file)
97 m_state = CURRENT_FILE_PUSHED;
98 }
99
100 void EndFile() {
101 if (m_file_stack.size() == 0)
102 return;
103
104 FileSpec old_top = m_file_stack.back();
105 m_file_stack.pop_back();
106 if (old_top == m_current_file)
107 m_state = CURRENT_FILE_POPPED;
108 }
109
110 // An entry is valid if it occurs before the current line in the current
111 // file.
112 bool IsValidEntry(uint32_t line) {
113 switch (m_state) {
114 case CURRENT_FILE_NOT_YET_PUSHED:
115 return true;
116 case CURRENT_FILE_PUSHED:
117 // If we are in file included in the current file, the entry should be
118 // added.
119 if (m_file_stack.back() != m_current_file)
120 return true;
121
122 return line < m_current_file_line;
123 default:
124 return false;
125 }
126 }
127
128private:
129 std::vector<FileSpec> m_file_stack;
130 State m_state;
131 FileSpec m_current_file;
132 uint32_t m_current_file_line;
133};
134
135} // anonymous namespace
136
137static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit,
138 AddMacroState &state, StreamString &stream) {
139 if (dm == nullptr)
140 return;
141
142 for (size_t i = 0; i < dm->GetNumMacroEntries(); i++) {
143 const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(i);
144 uint32_t line;
145
146 switch (entry.GetType()) {
147 case DebugMacroEntry::DEFINE:
148 if (state.IsValidEntry(entry.GetLineNumber()))
149 stream.Printf("#define %s\n", entry.GetMacroString().AsCString());
150 else
151 return;
152 break;
153 case DebugMacroEntry::UNDEF:
154 if (state.IsValidEntry(entry.GetLineNumber()))
155 stream.Printf("#undef %s\n", entry.GetMacroString().AsCString());
156 else
157 return;
158 break;
159 case DebugMacroEntry::START_FILE:
160 line = entry.GetLineNumber();
161 if (state.IsValidEntry(line))
162 state.StartFile(entry.GetFileSpec(comp_unit));
163 else
164 return;
165 break;
166 case DebugMacroEntry::END_FILE:
167 state.EndFile();
168 break;
169 case DebugMacroEntry::INDIRECT:
170 AddMacros(entry.GetIndirectDebugMacros(), comp_unit, state, stream);
171 break;
172 default:
173 // This is an unknown/invalid entry. Ignore.
174 break;
175 }
176 }
177}
178
179lldb_private::ClangExpressionSourceCode::ClangExpressionSourceCode(
180 llvm::StringRef filename, llvm::StringRef name, llvm::StringRef prefix,
181 llvm::StringRef body, Wrapping wrap, WrapKind wrap_kind)
182 : ExpressionSourceCode(name, prefix, body, wrap), m_wrap_kind(wrap_kind) {
183 // Use #line markers to pretend that we have a single-line source file
184 // containing only the user expression. This will hide our wrapper code
185 // from the user when we render diagnostics with Clang.
186 m_start_marker = "#line 1 \"" + filename.str() + "\"\n";
187 m_end_marker = g_expression_suffix;
188}
189
190namespace {
191/// Allows checking if a token is contained in a given expression.
192class TokenVerifier {
193 /// The tokens we found in the expression.
194 llvm::StringSet<> m_tokens;
195
196public:
197 TokenVerifier(std::string body);
198 /// Returns true iff the given expression body contained a token with the
199 /// given content.
200 bool hasToken(llvm::StringRef token) const {
201 return m_tokens.find(token) != m_tokens.end();
202 }
203};
204} // namespace
205
206TokenVerifier::TokenVerifier(std::string body) {
207 using namespace clang;
208
209 // We only care about tokens and not their original source locations. If we
210 // move the whole expression to only be in one line we can simplify the
211 // following code that extracts the token contents.
212 std::replace(body.begin(), body.end(), '\n', ' ');
213 std::replace(body.begin(), body.end(), '\r', ' ');
214
215 FileSystemOptions file_opts;
216 FileManager file_mgr(file_opts,
217 FileSystem::Instance().GetVirtualFileSystem());
218
219 // Let's build the actual source code Clang needs and setup some utility
220 // objects.
221 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_ids(new DiagnosticIDs());
222 llvm::IntrusiveRefCntPtr<DiagnosticOptions> diags_opts(
223 new DiagnosticOptions());
224 DiagnosticsEngine diags(diag_ids, diags_opts);
225 clang::SourceManager SM(diags, file_mgr);
226 auto buf = llvm::MemoryBuffer::getMemBuffer(body);
227
228 FileID FID = SM.createFileID(buf->getMemBufferRef());
229
230 // Let's just enable the latest ObjC and C++ which should get most tokens
231 // right.
232 LangOptions Opts;
233 Opts.ObjC = true;
234 Opts.DollarIdents = true;
235 Opts.CPlusPlus17 = true;
236 Opts.LineComment = true;
237
238 Lexer lex(FID, buf->getMemBufferRef(), SM, Opts);
239
240 Token token;
241 bool exit = false;
242 while (!exit) {
243 // Returns true if this is the last token we get from the lexer.
244 exit = lex.LexFromRawLexer(token);
245
246 // Extract the column number which we need to extract the token content.
247 // Our expression is just one line, so we don't need to handle any line
248 // numbers here.
249 bool invalid = false;
250 unsigned start = SM.getSpellingColumnNumber(token.getLocation(), &invalid);
251 if (invalid)
252 continue;
253 // Column numbers start at 1, but indexes in our string start at 0.
254 --start;
255
256 // Annotations don't have a length, so let's skip them.
257 if (token.isAnnotation())
258 continue;
259
260 // Extract the token string from our source code and store it.
261 std::string token_str = body.substr(start, token.getLength());
262 if (token_str.empty())
263 continue;
264 m_tokens.insert(token_str);
265 }
266}
267
268void ClangExpressionSourceCode::AddLocalVariableDecls(
269 const lldb::VariableListSP &var_list_sp, StreamString &stream,
270 const std::string &expr) const {
271 TokenVerifier tokens(expr);
272
273 for (size_t i = 0; i < var_list_sp->GetSize(); i++) {
274 lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
275
276 ConstString var_name = var_sp->GetName();
277
278
279 // We can check for .block_descriptor w/o checking for langauge since this
280 // is not a valid identifier in either C or C++.
281 if (!var_name || var_name == ".block_descriptor")
282 continue;
283
284 if (!expr.empty() && !tokens.hasToken(var_name.GetStringRef()))
285 continue;
286
287 const bool is_objc = m_wrap_kind == WrapKind::ObjCInstanceMethod ||
288 m_wrap_kind == WrapKind::ObjCStaticMethod;
289 if ((var_name == "self" || var_name == "_cmd") && is_objc)
290 continue;
291
292 if (var_name == "this" && m_wrap_kind == WrapKind::CppMemberFunction)
293 continue;
294
295 stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());
296 }
297}
298
299bool ClangExpressionSourceCode::GetText(
300 std::string &text, ExecutionContext &exe_ctx, bool add_locals,
301 bool force_add_all_locals, llvm::ArrayRef<std::string> modules) const {
302 const char *target_specific_defines = "typedef signed char BOOL;\n";
303 std::string module_macros;
304 llvm::raw_string_ostream module_macros_stream(module_macros);
305
306 Target *target = exe_ctx.GetTargetPtr();
1
'target' initialized here
→
307 if (target) {
2
←
Assuming 'target' is null
→
3
←
Taking false branch
→
308 if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64 ||
309 target->GetArchitecture().GetMachine() == llvm::Triple::aarch64_32) {
310 target_specific_defines = "typedef bool BOOL;\n";
311 }
312 if (target->GetArchitecture().GetMachine() == llvm::Triple::x86_64) {
313 if (lldb::PlatformSP platform_sp = target->GetPlatform()) {
314 static ConstString g_platform_ios_simulator("ios-simulator");
315 if (platform_sp->GetPluginName() == g_platform_ios_simulator) {
316 target_specific_defines = "typedef bool BOOL;\n";
317 }
318 }
319 }
320
321 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(
322 target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC));
323 std::shared_ptr<ClangModulesDeclVendor> decl_vendor =
324 persistent_vars->GetClangModulesDeclVendor();
325 if (decl_vendor) {
326 const ClangModulesDeclVendor::ModuleVector &hand_imported_modules =
327 persistent_vars->GetHandLoadedClangModules();
328 ClangModulesDeclVendor::ModuleVector modules_for_macros;
329
330 for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) {
331 modules_for_macros.push_back(module);
332 }
333
334 if (target->GetEnableAutoImportClangModules()) {
335 if (StackFrame *frame = exe_ctx.GetFramePtr()) {
336 if (Block *block = frame->GetFrameBlock()) {
337 SymbolContext sc;
338
339 block->CalculateSymbolContext(&sc);
340
341 if (sc.comp_unit) {
342 StreamString error_stream;
343
344 decl_vendor->AddModulesForCompileUnit(
345 *sc.comp_unit, modules_for_macros, error_stream);
346 }
347 }
348 }
349 }
350
351 decl_vendor->ForEachMacro(
352 modules_for_macros,
353 [&module_macros_stream](llvm::StringRef token,
354 llvm::StringRef expansion) -> bool {
355 // Check if the macro hasn't already been defined in the
356 // g_expression_prefix (which defines a few builtin macros).
357 module_macros_stream << "#ifndef " << token << "\n";
358 module_macros_stream << expansion << "\n";
359 module_macros_stream << "#endif\n";
360 return false;
361 });
362 }
363 }
364
365 StreamString debug_macros_stream;
366 StreamString lldb_local_var_decls;
367 if (StackFrame *frame = exe_ctx.GetFramePtr()) {
4
←
Assuming 'frame' is non-null
→
5
←
Taking true branch
→
368 const SymbolContext &sc = frame->GetSymbolContext(
369 lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry);
370
371 if (sc.comp_unit && sc.line_entry.IsValid()) {
6
←
Assuming field 'comp_unit' is null
→
372 DebugMacros *dm = sc.comp_unit->GetDebugMacros();
373 if (dm) {
374 AddMacroState state(sc.line_entry.file, sc.line_entry.line);
375 AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
376 }
377 }
378
379 if (add_locals)
7
←
Assuming 'add_locals' is true
→
8
←
Taking true branch
→
380 if (target->GetInjectLocalVariables(&exe_ctx)) {
9
←
Called C++ object pointer is null
381 lldb::VariableListSP var_list_sp =
382 frame->GetInScopeVariableList(false, true);
383 AddLocalVariableDecls(var_list_sp, lldb_local_var_decls,
384 force_add_all_locals ? "" : m_body);
385 }
386 }
387
388 if (m_wrap) {
389 // Generate a list of @import statements that will import the specified
390 // module into our expression.
391 std::string module_imports;
392 for (const std::string &module : modules) {
393 module_imports.append("@import ");
394 module_imports.append(module);
395 module_imports.append(";\n");
396 }
397
398 StreamString wrap_stream;
399
400 wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n", g_expression_prefix,
401 module_macros.c_str(), debug_macros_stream.GetData(),
402 target_specific_defines, m_prefix.c_str());
403
404 // First construct a tagged form of the user expression so we can find it
405 // later:
406 std::string tagged_body;
407 tagged_body.append(m_start_marker);
408 tagged_body.append(m_body);
409 tagged_body.append(m_end_marker);
410
411 switch (m_wrap_kind) {
412 case WrapKind::Function:
413 wrap_stream.Printf("%s"
414 "void \n"
415 "%s(void *$__lldb_arg) \n"
416 "{ \n"
417 " %s; \n"
418 "%s"
419 "} \n",
420 module_imports.c_str(), m_name.c_str(),
421 lldb_local_var_decls.GetData(), tagged_body.c_str());
422 break;
423 case WrapKind::CppMemberFunction:
424 wrap_stream.Printf("%s"
425 "void \n"
426 "$__lldb_class::%s(void *$__lldb_arg) \n"
427 "{ \n"
428 " %s; \n"
429 "%s"
430 "} \n",
431 module_imports.c_str(), m_name.c_str(),
432 lldb_local_var_decls.GetData(), tagged_body.c_str());
433 break;
434 case WrapKind::ObjCInstanceMethod:
435 wrap_stream.Printf(
436 "%s"
437 "@interface $__lldb_objc_class ($__lldb_category) \n"
438 "-(void)%s:(void *)$__lldb_arg; \n"
439 "@end \n"
440 "@implementation $__lldb_objc_class ($__lldb_category) \n"
441 "-(void)%s:(void *)$__lldb_arg \n"
442 "{ \n"
443 " %s; \n"
444 "%s"
445 "} \n"
446 "@end \n",
447 module_imports.c_str(), m_name.c_str(), m_name.c_str(),
448 lldb_local_var_decls.GetData(), tagged_body.c_str());
449 break;
450
451 case WrapKind::ObjCStaticMethod:
452 wrap_stream.Printf(
453 "%s"
454 "@interface $__lldb_objc_class ($__lldb_category) \n"
455 "+(void)%s:(void *)$__lldb_arg; \n"
456 "@end \n"
457 "@implementation $__lldb_objc_class ($__lldb_category) \n"
458 "+(void)%s:(void *)$__lldb_arg \n"
459 "{ \n"
460 " %s; \n"
461 "%s"
462 "} \n"
463 "@end \n",
464 module_imports.c_str(), m_name.c_str(), m_name.c_str(),
465 lldb_local_var_decls.GetData(), tagged_body.c_str());
466 break;
467 }
468
469 text = std::string(wrap_stream.GetString());
470 } else {
471 text.append(m_body);
472 }
473
474 return true;
475}
476
477bool ClangExpressionSourceCode::GetOriginalBodyBounds(
478 std::string transformed_text, size_t &start_loc, size_t &end_loc) {
479 start_loc = transformed_text.find(m_start_marker);
480 if (start_loc == std::string::npos)
481 return false;
482 start_loc += m_start_marker.size();
483 end_loc = transformed_text.find(m_end_marker);
484 return end_loc != std::string::npos;
485}