LLDB mainline
Block.cpp
Go to the documentation of this file.
1//===-- Block.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/Symbol/Block.h"
10
11#include "lldb/Core/Module.h"
12#include "lldb/Core/Section.h"
17#include "lldb/Utility/Log.h"
18
19#include <memory>
20
21using namespace lldb;
22using namespace lldb_private;
23
25 : UserID(uid), m_parent_scope(nullptr), m_children(), m_ranges(),
26 m_inlineInfoSP(), m_variable_list_sp(), m_parsed_block_info(false),
27 m_parsed_block_variables(false), m_parsed_child_blocks(false) {}
28
29Block::~Block() = default;
30
32 lldb::DescriptionLevel level, Target *target) const {
33 *s << "id = " << ((const UserID &)*this);
34
35 size_t num_ranges = m_ranges.GetSize();
36 if (num_ranges > 0) {
37
38 addr_t base_addr = LLDB_INVALID_ADDRESS;
39 if (target)
40 base_addr =
41 function->GetAddressRange().GetBaseAddress().GetLoadAddress(target);
42 if (base_addr == LLDB_INVALID_ADDRESS)
43 base_addr = function->GetAddressRange().GetBaseAddress().GetFileAddress();
44
45 s->Printf(", range%s = ", num_ranges > 1 ? "s" : "");
46 for (size_t i = 0; i < num_ranges; ++i) {
47 const Range &range = m_ranges.GetEntryRef(i);
48 DumpAddressRange(s->AsRawOstream(), base_addr + range.GetRangeBase(),
49 base_addr + range.GetRangeEnd(), 4);
50 }
51 }
52
53 if (m_inlineInfoSP.get() != nullptr) {
54 bool show_fullpaths = (level == eDescriptionLevelVerbose);
55 m_inlineInfoSP->Dump(s, show_fullpaths);
56 }
57}
58
59void Block::Dump(Stream *s, addr_t base_addr, int32_t depth,
60 bool show_context) const {
61 if (depth < 0) {
62 Block *parent = GetParent();
63 if (parent) {
64 // We have a depth that is less than zero, print our parent blocks first
65 parent->Dump(s, base_addr, depth + 1, show_context);
66 }
67 }
68
69 s->Printf("%p: ", static_cast<const void *>(this));
70 s->Indent();
71 *s << "Block" << static_cast<const UserID &>(*this);
72 const Block *parent_block = GetParent();
73 if (parent_block) {
74 s->Printf(", parent = {0x%8.8" PRIx64 "}", parent_block->GetID());
75 }
76 if (m_inlineInfoSP.get() != nullptr) {
77 bool show_fullpaths = false;
78 m_inlineInfoSP->Dump(s, show_fullpaths);
79 }
80
81 if (!m_ranges.IsEmpty()) {
82 *s << ", ranges =";
83
84 size_t num_ranges = m_ranges.GetSize();
85 for (size_t i = 0; i < num_ranges; ++i) {
86 const Range &range = m_ranges.GetEntryRef(i);
87 if (parent_block != nullptr && !parent_block->Contains(range))
88 *s << '!';
89 else
90 *s << ' ';
91 DumpAddressRange(s->AsRawOstream(), base_addr + range.GetRangeBase(),
92 base_addr + range.GetRangeEnd(), 4);
93 }
94 }
95 s->EOL();
96
97 if (depth > 0) {
98 s->IndentMore();
99
100 if (m_variable_list_sp.get()) {
101 m_variable_list_sp->Dump(s, show_context);
102 }
103
104 collection::const_iterator pos, end = m_children.end();
105 for (pos = m_children.begin(); pos != end; ++pos)
106 (*pos)->Dump(s, base_addr, depth - 1, show_context);
107
108 s->IndentLess();
109 }
110}
111
113 if (block_id == GetID())
114 return this;
115
116 Block *matching_block = nullptr;
117 collection::const_iterator pos, end = m_children.end();
118 for (pos = m_children.begin(); pos != end; ++pos) {
119 matching_block = (*pos)->FindBlockByID(block_id);
120 if (matching_block)
121 break;
122 }
123 return matching_block;
124}
125
127 if (!Contains(offset))
128 return nullptr;
129 for (const BlockSP &block_sp : m_children) {
130 if (Block *block = block_sp->FindInnermostBlockByOffset(offset))
131 return block;
132 }
133 return this;
134}
135
137 if (m_parent_scope)
139 sc->block = this;
140}
141
143 if (m_parent_scope)
145 return lldb::ModuleSP();
146}
147
149 if (m_parent_scope)
151 return nullptr;
152}
153
155 if (m_parent_scope)
157 return nullptr;
158}
159
161
164 if (function)
165 function->DumpSymbolContext(s);
166 s->Printf(", Block{0x%8.8" PRIx64 "}", GetID());
167}
168
170 if (!m_ranges.IsEmpty()) {
171 size_t num_ranges = m_ranges.GetSize();
172 for (size_t i = 0; i < num_ranges; ++i) {
173 const Range &range = m_ranges.GetEntryRef(i);
174 DumpAddressRange(s->AsRawOstream(), base_addr + range.GetRangeBase(),
175 base_addr + range.GetRangeEnd(), 4);
176 }
177 }
178}
179
180bool Block::Contains(addr_t range_offset) const {
181 return m_ranges.FindEntryThatContains(range_offset) != nullptr;
182}
183
184bool Block::Contains(const Block *block) const {
185 if (this == block)
186 return false; // This block doesn't contain itself...
187
188 // Walk the parent chain for "block" and see if any if them match this block
189 const Block *block_parent;
190 for (block_parent = block->GetParent(); block_parent != nullptr;
191 block_parent = block_parent->GetParent()) {
192 if (this == block_parent)
193 return true; // One of the parents of "block" is this object!
194 }
195 return false;
196}
197
198bool Block::Contains(const Range &range) const {
199 return m_ranges.FindEntryThatContains(range) != nullptr;
200}
201
203 if (m_parent_scope)
205 return nullptr;
206}
207
210 return this;
211 return GetInlinedParent();
212}
213
215 Block *parent_block = GetParent();
216 if (parent_block) {
217 if (parent_block->GetInlinedFunctionInfo())
218 return parent_block;
219 else
220 return parent_block->GetInlinedParent();
221 }
222 return nullptr;
223}
224
226 const Declaration &find_call_site) {
227 Block *inlined_block = GetContainingInlinedBlock();
228
229 while (inlined_block) {
230 const auto *function_info = inlined_block->GetInlinedFunctionInfo();
231
232 if (function_info &&
233 function_info->GetCallSite().FileAndLineEqual(find_call_site))
234 return inlined_block;
235 inlined_block = inlined_block->GetInlinedParent();
236 }
237 return nullptr;
238}
239
240bool Block::GetRangeContainingOffset(const addr_t offset, Range &range) {
241 const Range *range_ptr = m_ranges.FindEntryThatContains(offset);
242 if (range_ptr) {
243 range = *range_ptr;
244 return true;
245 }
246 range.Clear();
247 return false;
248}
249
251 AddressRange &range) {
253 if (function) {
254 const AddressRange &func_range = function->GetAddressRange();
255 if (addr.GetSection() == func_range.GetBaseAddress().GetSection()) {
256 const addr_t addr_offset = addr.GetOffset();
257 const addr_t func_offset = func_range.GetBaseAddress().GetOffset();
258 if (addr_offset >= func_offset &&
259 addr_offset < func_offset + func_range.GetByteSize()) {
260 addr_t offset = addr_offset - func_offset;
261
262 const Range *range_ptr = m_ranges.FindEntryThatContains(offset);
263
264 if (range_ptr) {
265 range.GetBaseAddress() = func_range.GetBaseAddress();
266 range.GetBaseAddress().SetOffset(func_offset +
267 range_ptr->GetRangeBase());
268 range.SetByteSize(range_ptr->GetByteSize());
269 return true;
270 }
271 }
272 }
273 }
274 range.Clear();
275 return false;
276}
277
279 Target &target, AddressRange &range) {
280 Address load_address;
281 load_address.SetLoadAddress(load_addr, &target);
282 AddressRange containing_range;
283 return GetRangeContainingAddress(load_address, containing_range);
284}
285
288 if (function) {
289 const AddressRange &func_range = function->GetAddressRange();
290 if (addr.GetSection() == func_range.GetBaseAddress().GetSection()) {
291 const addr_t addr_offset = addr.GetOffset();
292 const addr_t func_offset = func_range.GetBaseAddress().GetOffset();
293 if (addr_offset >= func_offset &&
294 addr_offset < func_offset + func_range.GetByteSize()) {
295 addr_t offset = addr_offset - func_offset;
297 }
298 }
299 }
300 return UINT32_MAX;
301}
302
303bool Block::GetRangeAtIndex(uint32_t range_idx, AddressRange &range) {
304 if (range_idx < m_ranges.GetSize()) {
306 if (function) {
307 const Range &vm_range = m_ranges.GetEntryRef(range_idx);
308 range.GetBaseAddress() = function->GetAddressRange().GetBaseAddress();
309 range.GetBaseAddress().Slide(vm_range.GetRangeBase());
310 range.SetByteSize(vm_range.GetByteSize());
311 return true;
312 }
313 }
314 return false;
315}
316
318 AddressRanges ranges;
320 if (!function)
321 return ranges;
322 for (size_t i = 0, e = m_ranges.GetSize(); i < e; ++i) {
323 ranges.emplace_back();
324 auto &range = ranges.back();
325 const Range &vm_range = m_ranges.GetEntryRef(i);
326 range.GetBaseAddress() = function->GetAddressRange().GetBaseAddress();
327 range.GetBaseAddress().Slide(vm_range.GetRangeBase());
328 range.SetByteSize(vm_range.GetByteSize());
329 }
330 return ranges;
331}
332
334 if (m_ranges.IsEmpty())
335 return false;
336
338 if (function) {
339 addr = function->GetAddressRange().GetBaseAddress();
341 return true;
342 }
343 return false;
344}
345
347 m_ranges.Sort();
349}
350
351void Block::AddRange(const Range &range) {
352 Block *parent_block = GetParent();
353 if (parent_block && !parent_block->Contains(range)) {
355 if (log) {
358 const addr_t function_file_addr =
360 const addr_t block_start_addr = function_file_addr + range.GetRangeBase();
361 const addr_t block_end_addr = function_file_addr + range.GetRangeEnd();
362 Type *func_type = function->GetType();
363
364 const Declaration &func_decl = func_type->GetDeclaration();
365 if (func_decl.GetLine()) {
366 LLDB_LOGF(log,
367 "warning: %s:%u block {0x%8.8" PRIx64
368 "} has range[%u] [0x%" PRIx64 " - 0x%" PRIx64
369 ") which is not contained in parent block {0x%8.8" PRIx64
370 "} in function {0x%8.8" PRIx64 "} from %s",
371 func_decl.GetFile().GetPath().c_str(), func_decl.GetLine(),
372 GetID(), (uint32_t)m_ranges.GetSize(), block_start_addr,
373 block_end_addr, parent_block->GetID(), function->GetID(),
374 module_sp->GetFileSpec().GetPath().c_str());
375 } else {
376 LLDB_LOGF(log,
377 "warning: block {0x%8.8" PRIx64 "} has range[%u] [0x%" PRIx64
378 " - 0x%" PRIx64
379 ") which is not contained in parent block {0x%8.8" PRIx64
380 "} in function {0x%8.8" PRIx64 "} from %s",
381 GetID(), (uint32_t)m_ranges.GetSize(), block_start_addr,
382 block_end_addr, parent_block->GetID(), function->GetID(),
383 module_sp->GetFileSpec().GetPath().c_str());
384 }
385 }
386 parent_block->AddRange(range);
387 }
388 m_ranges.Append(range);
389}
390
391// Return the current number of bytes that this object occupies in memory
392size_t Block::MemorySize() const {
393 size_t mem_size = sizeof(Block) + m_ranges.GetSize() * sizeof(Range);
394 if (m_inlineInfoSP.get())
395 mem_size += m_inlineInfoSP->MemorySize();
396 if (m_variable_list_sp.get())
397 mem_size += m_variable_list_sp->MemorySize();
398 return mem_size;
399}
400
401void Block::AddChild(const BlockSP &child_block_sp) {
402 if (child_block_sp) {
403 child_block_sp->SetParentScope(this);
404 m_children.push_back(child_block_sp);
405 }
406}
407
408void Block::SetInlinedFunctionInfo(const char *name, const char *mangled,
409 const Declaration *decl_ptr,
410 const Declaration *call_decl_ptr) {
411 m_inlineInfoSP = std::make_shared<InlineFunctionInfo>(name, mangled, decl_ptr,
412 call_decl_ptr);
413}
414
417 if (m_variable_list_sp.get() == nullptr && can_create) {
419 SymbolContext sc;
421 assert(sc.module_sp);
422 sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc);
423 }
424 }
425 return m_variable_list_sp;
426}
427
428uint32_t
429Block::AppendBlockVariables(bool can_create, bool get_child_block_variables,
430 bool stop_if_child_block_is_inlined_function,
431 const std::function<bool(Variable *)> &filter,
432 VariableList *variable_list) {
433 uint32_t num_variables_added = 0;
434 VariableList *block_var_list = GetBlockVariableList(can_create).get();
435 if (block_var_list) {
436 for (const VariableSP &var_sp : *block_var_list) {
437 if (filter(var_sp.get())) {
438 num_variables_added++;
439 variable_list->AddVariable(var_sp);
440 }
441 }
442 }
443
444 if (get_child_block_variables) {
445 collection::const_iterator pos, end = m_children.end();
446 for (pos = m_children.begin(); pos != end; ++pos) {
447 Block *child_block = pos->get();
448 if (!stop_if_child_block_is_inlined_function ||
449 child_block->GetInlinedFunctionInfo() == nullptr) {
450 num_variables_added += child_block->AppendBlockVariables(
451 can_create, get_child_block_variables,
452 stop_if_child_block_is_inlined_function, filter, variable_list);
453 }
454 }
455 }
456 return num_variables_added;
457}
458
459uint32_t Block::AppendVariables(bool can_create, bool get_parent_variables,
460 bool stop_if_block_is_inlined_function,
461 const std::function<bool(Variable *)> &filter,
462 VariableList *variable_list) {
463 uint32_t num_variables_added = 0;
464 VariableListSP variable_list_sp(GetBlockVariableList(can_create));
465
466 bool is_inlined_function = GetInlinedFunctionInfo() != nullptr;
467 if (variable_list_sp) {
468 for (size_t i = 0; i < variable_list_sp->GetSize(); ++i) {
469 VariableSP variable = variable_list_sp->GetVariableAtIndex(i);
470 if (filter(variable.get())) {
471 num_variables_added++;
472 variable_list->AddVariable(variable);
473 }
474 }
475 }
476
477 if (get_parent_variables) {
478 if (stop_if_block_is_inlined_function && is_inlined_function)
479 return num_variables_added;
480
481 Block *parent_block = GetParent();
482 if (parent_block)
483 num_variables_added += parent_block->AppendVariables(
484 can_create, get_parent_variables, stop_if_block_is_inlined_function,
485 filter, variable_list);
486 }
487 return num_variables_added;
488}
489
491 if (ModuleSP module_sp = CalculateSymbolContextModule())
492 return module_sp->GetSymbolFile();
493 return nullptr;
494}
495
497 if (SymbolFile *sym_file = GetSymbolFile())
498 return sym_file->GetDeclContextForUID(GetID());
499 return CompilerDeclContext();
500}
501
502void Block::SetBlockInfoHasBeenParsed(bool b, bool set_children) {
504 if (set_children) {
506 collection::const_iterator pos, end = m_children.end();
507 for (pos = m_children.begin(); pos != end; ++pos)
508 (*pos)->SetBlockInfoHasBeenParsed(b, true);
509 }
510}
511
512void Block::SetDidParseVariables(bool b, bool set_children) {
514 if (set_children) {
515 collection::const_iterator pos, end = m_children.end();
516 for (pos = m_children.begin(); pos != end; ++pos)
517 (*pos)->SetDidParseVariables(b, true);
518 }
519}
520
522 if (m_parent_scope) {
523 Block *parent_block = GetParent();
524 if (parent_block)
525 return parent_block->GetSiblingForChild(this);
526 }
527 return nullptr;
528}
529// A parent of child blocks can be asked to find a sibling block given
530// one of its child blocks
531Block *Block::GetSiblingForChild(const Block *child_block) const {
532 if (!m_children.empty()) {
533 collection::const_iterator pos, end = m_children.end();
534 for (pos = m_children.begin(); pos != end; ++pos) {
535 if (pos->get() == child_block) {
536 if (++pos != end)
537 return pos->get();
538 break;
539 }
540 }
541 }
542 return nullptr;
543}
#define LLDB_LOGF(log,...)
Definition: Log.h:366
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:211
void Clear()
Clear the object's state.
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:239
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:223
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:1047
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:439
bool Slide(int64_t offset)
Definition: Address.h:459
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:293
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:329
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:448
A class that describes a single lexical block.
Definition: Block.h:41
RangeList::Entry Range
Definition: Block.h:44
lldb::VariableListSP m_variable_list_sp
The variable list for all local, static and parameter variables scoped to this block.
Definition: Block.h:371
lldb::VariableListSP GetBlockVariableList(bool can_create)
Get the variable list for this block only.
Definition: Block.cpp:415
Block * GetContainingInlinedBlockWithCallSite(const Declaration &find_call_site)
Get the inlined block at the given call site that contains this block.
Definition: Block.cpp:225
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: Block.cpp:136
Block * FindInnermostBlockByOffset(const lldb::addr_t offset)
Definition: Block.cpp:126
lldb::ModuleSP CalculateSymbolContextModule() override
Definition: Block.cpp:142
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
Definition: Block.cpp:208
void SetBlockInfoHasBeenParsed(bool b, bool set_children)
Definition: Block.cpp:502
bool GetRangeAtIndex(uint32_t range_idx, AddressRange &range)
Definition: Block.cpp:303
const InlineFunctionInfo * GetInlinedFunctionInfo() const
Get const accessor for any inlined function information.
Definition: Block.h:276
AddressRanges GetRanges()
Definition: Block.cpp:317
bool m_parsed_child_blocks
Definition: Block.h:376
lldb::InlineFunctionInfoSP m_inlineInfoSP
Inlined function information.
Definition: Block.h:370
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: Block.cpp:162
bool GetRangeContainingAddress(const Address &addr, AddressRange &range)
Definition: Block.cpp:250
Block * FindBlockByID(lldb::user_id_t block_id)
Definition: Block.cpp:112
bool m_parsed_block_info
Set to true if this block and it's children have all been parsed.
Definition: Block.h:375
Block * GetSibling() const
Get the sibling block for this block.
Definition: Block.cpp:521
bool Contains(lldb::addr_t range_offset) const
Check if an offset is in one of the block offset ranges.
Definition: Block.cpp:180
SymbolContextScope * m_parent_scope
Definition: Block.h:367
CompileUnit * CalculateSymbolContextCompileUnit() override
Definition: Block.cpp:148
Block * GetSiblingForChild(const Block *child_block) const
Definition: Block.cpp:531
Function * CalculateSymbolContextFunction() override
Definition: Block.cpp:154
bool GetRangeContainingLoadAddress(lldb::addr_t load_addr, Target &target, AddressRange &range)
Definition: Block.cpp:278
CompilerDeclContext GetDeclContext()
Definition: Block.cpp:496
collection m_children
Definition: Block.h:368
bool m_parsed_block_variables
Definition: Block.h:376
Block * GetParent() const
Get the parent block.
Definition: Block.cpp:202
~Block() override
Destructor.
uint32_t AppendVariables(bool can_create, bool get_parent_variables, bool stop_if_block_is_inlined_function, const std::function< bool(Variable *)> &filter, VariableList *variable_list)
Appends the variables from this block, and optionally from all parent blocks, to variable_list.
Definition: Block.cpp:459
bool GetStartAddress(Address &addr)
Definition: Block.cpp:333
SymbolFile * GetSymbolFile()
Get the symbol file which contains debug info for this block's symbol context module.
Definition: Block.cpp:490
void Dump(Stream *s, lldb::addr_t base_addr, int32_t depth, bool show_context) const
Dump the block contents.
Definition: Block.cpp:59
void SetDidParseVariables(bool b, bool set_children)
Definition: Block.cpp:512
bool GetRangeContainingOffset(const lldb::addr_t offset, Range &range)
Definition: Block.cpp:240
void AddRange(const Range &range)
Add a new offset range to this block.
Definition: Block.cpp:351
Block(lldb::user_id_t uid)
Construct with a User ID uid, depth.
Definition: Block.cpp:24
Block * CalculateSymbolContextBlock() override
Definition: Block.cpp:160
void DumpAddressRanges(Stream *s, lldb::addr_t base_addr)
Definition: Block.cpp:169
Block * GetInlinedParent()
Get the inlined parent block for this block.
Definition: Block.cpp:214
void FinalizeRanges()
Definition: Block.cpp:346
uint32_t GetRangeIndexContainingAddress(const Address &addr)
Definition: Block.cpp:286
void AddChild(const lldb::BlockSP &child_block_sp)
Add a child to this object.
Definition: Block.cpp:401
void SetInlinedFunctionInfo(const char *name, const char *mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr)
Set accessor for any inlined function information.
Definition: Block.cpp:408
size_t MemorySize() const
Get the memory cost of this object.
Definition: Block.cpp:392
uint32_t AppendBlockVariables(bool can_create, bool get_child_block_variables, bool stop_if_child_block_is_inlined_function, const std::function< bool(Variable *)> &filter, VariableList *variable_list)
Get the variable list for this block and optionally all child blocks if get_child_variables is true.
Definition: Block.cpp:429
void GetDescription(Stream *s, Function *function, lldb::DescriptionLevel level, Target *target) const
Definition: Block.cpp:31
RangeList m_ranges
Definition: Block.h:369
A class that describes a compilation unit.
Definition: CompileUnit.h:41
Represents a generic declaration context in a program.
A class that describes the declaration location of a lldb object.
Definition: Declaration.h:24
uint32_t GetLine() const
Get accessor for the declaration line number.
Definition: Declaration.h:120
FileSpec & GetFile()
Get accessor for file specification.
Definition: Declaration.h:107
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
A class that describes a function.
Definition: Function.h:399
const AddressRange & GetAddressRange()
Definition: Function.h:447
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: Function.cpp:491
Type * GetType()
Get accessor for the type that describes the function return value type, and parameter types.
Definition: Function.cpp:539
const Entry * FindEntryThatContains(B addr) const
Definition: RangeMap.h:338
uint32_t FindEntryIndexThatContains(B addr) const
Definition: RangeMap.h:316
Entry & GetEntryRef(size_t i)
Definition: RangeMap.h:303
void Append(const Entry &entry)
Definition: RangeMap.h:179
bool IsEmpty() const
Definition: RangeMap.h:293
size_t GetSize() const
Definition: RangeMap.h:295
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:401
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:157
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:198
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:195
virtual Function * CalculateSymbolContextFunction()
virtual CompileUnit * CalculateSymbolContextCompileUnit()
virtual void CalculateSymbolContext(SymbolContext *sc)=0
Reconstruct the object's symbol context into sc.
virtual Block * CalculateSymbolContextBlock()
virtual lldb::ModuleSP CalculateSymbolContextModule()
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
Block * block
The Block for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:50
const lldb_private::Declaration & GetDeclaration() const
Definition: Type.cpp:568
void AddVariable(const lldb::VariableSP &var_sp)
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
void DumpAddressRange(llvm::raw_ostream &s, uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size, const char *prefix=nullptr, const char *suffix=nullptr)
Output an address range to this stream.
Definition: Stream.cpp:120
Definition: SBAddress.h:15
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
@ eDescriptionLevelVerbose
std::shared_ptr< lldb_private::Block > BlockSP
Definition: lldb-forward.h:317
std::shared_ptr< lldb_private::VariableList > VariableListSP
Definition: lldb-forward.h:482
std::shared_ptr< lldb_private::Variable > VariableSP
Definition: lldb-forward.h:481
uint64_t user_id_t
Definition: lldb-types.h:82
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:370
void Clear(BaseType b=0)
Definition: RangeMap.h:40
BaseType GetRangeBase() const
Definition: RangeMap.h:45
SizeType GetByteSize() const
Definition: RangeMap.h:87
BaseType GetRangeEnd() const
Definition: RangeMap.h:78
A mix in class that contains a generic user ID.
Definition: UserID.h:31
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47