Bug Summary

File:tools/lldb/source/Breakpoint/BreakpointResolver.cpp
Warning:line 146, column 5
Called C++ object pointer is uninitialized

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name BreakpointResolver.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D LLDB_USE_BUILTIN_DEMANGLER -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn336939/build-llvm/tools/lldb/source/Breakpoint -I /build/llvm-toolchain-snapshot-7~svn336939/tools/lldb/source/Breakpoint -I /build/llvm-toolchain-snapshot-7~svn336939/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn336939/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn336939/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn336939/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-7~svn336939/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn336939/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-7~svn336939/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn336939/build-llvm/tools/lldb/source/Breakpoint -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-13-043813-3945-1 -x c++ /build/llvm-toolchain-snapshot-7~svn336939/tools/lldb/source/Breakpoint/BreakpointResolver.cpp
1//===-- BreakpointResolver.cpp ----------------------------------*- 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#include "lldb/Breakpoint/BreakpointResolver.h"
11
12// C Includes
13// C++ Includes
14// Other libraries and framework includes
15// Project includes
16#include "lldb/Breakpoint/Breakpoint.h"
17#include "lldb/Breakpoint/BreakpointLocation.h"
18// Have to include the other breakpoint resolver types here so the static
19// create from StructuredData can call them.
20#include "lldb/Breakpoint/BreakpointResolverAddress.h"
21#include "lldb/Breakpoint/BreakpointResolverFileLine.h"
22#include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
23#include "lldb/Breakpoint/BreakpointResolverName.h"
24#include "lldb/Core/Address.h"
25#include "lldb/Core/ModuleList.h"
26#include "lldb/Core/SearchFilter.h"
27#include "lldb/Symbol/CompileUnit.h"
28#include "lldb/Symbol/Function.h"
29#include "lldb/Symbol/SymbolContext.h"
30#include "lldb/Target/Target.h"
31#include "lldb/Utility/Log.h"
32#include "lldb/Utility/Stream.h"
33#include "lldb/Utility/StreamString.h"
34
35using namespace lldb_private;
36using namespace lldb;
37
38//----------------------------------------------------------------------
39// BreakpointResolver:
40//----------------------------------------------------------------------
41const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
42 "SymbolName", "SourceRegex",
43 "Exception", "Unknown"};
44
45const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
46 BreakpointResolver::OptionNames::LastOptionName)] = {
47 "AddressOffset", "Exact", "FileName", "Inlines", "Language",
48 "LineNumber", "ModuleName", "NameMask", "Offset", "Regex",
49 "SectionName", "SkipPrologue", "SymbolNames"};
50
51const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
52 if (type > LastKnownResolverType)
53 return g_ty_to_name[UnknownResolver];
54
55 return g_ty_to_name[type];
56}
57
58BreakpointResolver::ResolverTy
59BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
60 for (size_t i = 0; i < LastKnownResolverType; i++) {
61 if (name == g_ty_to_name[i])
62 return (ResolverTy)i;
63 }
64 return UnknownResolver;
65}
66
67BreakpointResolver::BreakpointResolver(Breakpoint *bkpt,
68 const unsigned char resolverTy,
69 lldb::addr_t offset)
70 : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
71
72BreakpointResolver::~BreakpointResolver() {}
73
74BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
75 const StructuredData::Dictionary &resolver_dict, Status &error) {
76 BreakpointResolverSP result_sp;
77 if (!resolver_dict.IsValid()) {
1
Assuming the condition is false
2
Taking false branch
78 error.SetErrorString("Can't deserialize from an invalid data object.");
79 return result_sp;
80 }
81
82 llvm::StringRef subclass_name;
83
84 bool success = resolver_dict.GetValueForKeyAsString(
85 GetSerializationSubclassKey(), subclass_name);
86
87 if (!success) {
3
Taking false branch
88 error.SetErrorStringWithFormat(
89 "Resolver data missing subclass resolver key");
90 return result_sp;
91 }
92
93 ResolverTy resolver_type = NameToResolverTy(subclass_name);
94 if (resolver_type == UnknownResolver) {
4
Assuming 'resolver_type' is not equal to UnknownResolver
5
Taking false branch
95 error.SetErrorStringWithFormatv("Unknown resolver type: {0}.",
96 subclass_name);
97 return result_sp;
98 }
99
100 StructuredData::Dictionary *subclass_options = nullptr;
101 success = resolver_dict.GetValueForKeyAsDictionary(
102 GetSerializationSubclassOptionsKey(), subclass_options);
103 if (!success || !subclass_options || !subclass_options->IsValid()) {
6
Assuming the condition is false
7
Taking false branch
104 error.SetErrorString("Resolver data missing subclass options key.");
105 return result_sp;
106 }
107
108 lldb::addr_t offset;
109 success = subclass_options->GetValueForKeyAsInteger(
110 GetKey(OptionNames::Offset), offset);
111 if (!success) {
8
Taking false branch
112 error.SetErrorString("Resolver data missing offset options key.");
113 return result_sp;
114 }
115
116 BreakpointResolver *resolver;
9
'resolver' declared without an initial value
117
118 switch (resolver_type) {
10
Control jumps to 'case ExceptionResolver:' at line 135
119 case FileLineResolver:
120 resolver = BreakpointResolverFileLine::CreateFromStructuredData(
121 nullptr, *subclass_options, error);
122 break;
123 case AddressResolver:
124 resolver = BreakpointResolverAddress::CreateFromStructuredData(
125 nullptr, *subclass_options, error);
126 break;
127 case NameResolver:
128 resolver = BreakpointResolverName::CreateFromStructuredData(
129 nullptr, *subclass_options, error);
130 break;
131 case FileRegexResolver:
132 resolver = BreakpointResolverFileRegex::CreateFromStructuredData(
133 nullptr, *subclass_options, error);
134 break;
135 case ExceptionResolver:
136 error.SetErrorString("Exception resolvers are hard.");
137 break;
11
Execution continues on line 142
138 default:
139 llvm_unreachable("Should never get an unresolvable resolver type.")::llvm::llvm_unreachable_internal("Should never get an unresolvable resolver type."
, "/build/llvm-toolchain-snapshot-7~svn336939/tools/lldb/source/Breakpoint/BreakpointResolver.cpp"
, 139)
;
140 }
141
142 if (!error.Success()) {
12
Assuming the condition is false
13
Taking false branch
143 return result_sp;
144 } else {
145 // Add on the global offset option:
146 resolver->SetOffset(offset);
14
Called C++ object pointer is uninitialized
147 return BreakpointResolverSP(resolver);
148 }
149}
150
151StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
152 StructuredData::DictionarySP options_dict_sp) {
153 if (!options_dict_sp || !options_dict_sp->IsValid())
154 return StructuredData::DictionarySP();
155
156 StructuredData::DictionarySP type_dict_sp(new StructuredData::Dictionary());
157 type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName());
158 type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
159
160 // Add the m_offset to the dictionary:
161 options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
162
163 return type_dict_sp;
164}
165
166void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) {
167 m_breakpoint = bkpt;
168}
169
170void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
171 ModuleList &modules) {
172 filter.SearchInModuleList(*this, modules);
173}
174
175void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
176 filter.Search(*this);
177}
178
179void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter,
180 SymbolContextList &sc_list,
181 bool skip_prologue,
182 llvm::StringRef log_ident) {
183 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
184
185 while (sc_list.GetSize() > 0) {
186 SymbolContextList tmp_sc_list;
187 unsigned current_idx = 0;
188 SymbolContext sc;
189 bool first_entry = true;
190
191 FileSpec match_file_spec;
192 FileSpec match_original_file_spec;
193 uint32_t closest_line_number = UINT32_MAX(4294967295U);
194
195 // Pull out the first entry, and all the others that match its file spec,
196 // and stuff them in the tmp list.
197 while (current_idx < sc_list.GetSize()) {
198 bool matches;
199
200 sc_list.GetContextAtIndex(current_idx, sc);
201 if (first_entry) {
202 match_file_spec = sc.line_entry.file;
203 match_original_file_spec = sc.line_entry.original_file;
204 matches = true;
205 first_entry = false;
206 } else
207 matches = ((sc.line_entry.file == match_file_spec) ||
208 (sc.line_entry.original_file == match_original_file_spec));
209
210 if (matches) {
211 tmp_sc_list.Append(sc);
212 sc_list.RemoveContextAtIndex(current_idx);
213
214 // ResolveSymbolContext will always return a number that is >= the line
215 // number you pass in. So the smaller line number is always better.
216 if (sc.line_entry.line < closest_line_number)
217 closest_line_number = sc.line_entry.line;
218 } else
219 current_idx++;
220 }
221
222 // Okay, we've found the closest line number match, now throw away all the
223 // others:
224
225 current_idx = 0;
226 while (current_idx < tmp_sc_list.GetSize()) {
227 if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) {
228 if (sc.line_entry.line != closest_line_number)
229 tmp_sc_list.RemoveContextAtIndex(current_idx);
230 else
231 current_idx++;
232 }
233 }
234
235 // Next go through and see if there are line table entries that are
236 // contiguous, and if so keep only the first of the contiguous range:
237
238 current_idx = 0;
239 std::map<Block *, lldb::addr_t> blocks_with_breakpoints;
240
241 while (current_idx < tmp_sc_list.GetSize()) {
242 if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) {
243 if (blocks_with_breakpoints.find(sc.block) !=
244 blocks_with_breakpoints.end())
245 tmp_sc_list.RemoveContextAtIndex(current_idx);
246 else {
247 blocks_with_breakpoints.insert(std::pair<Block *, lldb::addr_t>(
248 sc.block, sc.line_entry.range.GetBaseAddress().GetFileAddress()));
249 current_idx++;
250 }
251 }
252 }
253
254 // and make breakpoints out of the closest line number match.
255
256 uint32_t tmp_sc_list_size = tmp_sc_list.GetSize();
257
258 for (uint32_t i = 0; i < tmp_sc_list_size; i++) {
259 if (tmp_sc_list.GetContextAtIndex(i, sc)) {
260 Address line_start = sc.line_entry.range.GetBaseAddress();
261 if (line_start.IsValid()) {
262 if (filter.AddressPasses(line_start)) {
263 // If the line number is before the prologue end, move it there...
264 bool skipped_prologue = false;
265 if (skip_prologue) {
266 if (sc.function) {
267 Address prologue_addr(
268 sc.function->GetAddressRange().GetBaseAddress());
269 if (prologue_addr.IsValid() && (line_start == prologue_addr)) {
270 const uint32_t prologue_byte_size =
271 sc.function->GetPrologueByteSize();
272 if (prologue_byte_size) {
273 prologue_addr.Slide(prologue_byte_size);
274
275 if (filter.AddressPasses(prologue_addr)) {
276 skipped_prologue = true;
277 line_start = prologue_addr;
278 }
279 }
280 }
281 }
282 }
283
284 BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
285 if (log && bp_loc_sp && !m_breakpoint->IsInternal()) {
286 StreamString s;
287 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
288 log->Printf("Added location (skipped prologue: %s): %s \n",
289 skipped_prologue ? "yes" : "no", s.GetData());
290 }
291 } else if (log) {
292 log->Printf("Breakpoint %s at file address 0x%" PRIx64"l" "x"
293 " didn't pass the filter.\n",
294 log_ident.str().c_str(), line_start.GetFileAddress());
295 }
296 } else {
297 if (log)
298 log->Printf(
299 "error: Unable to set breakpoint %s at file address 0x%" PRIx64"l" "x"
300 "\n",
301 log_ident.str().c_str(), line_start.GetFileAddress());
302 }
303 }
304 }
305 }
306}
307
308BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
309 bool *new_location) {
310 loc_addr.Slide(m_offset);
311 return m_breakpoint->AddLocation(loc_addr, new_location);
312}
313
314void BreakpointResolver::SetOffset(lldb::addr_t offset) {
315 // There may already be an offset, so we are actually adjusting location
316 // addresses by the difference.
317 // lldb::addr_t slide = offset - m_offset;
318 // FIXME: We should go fix up all the already set locations for the new slide.
319
320 m_offset = offset;
321}