1 //===-- Block.h -------------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef liblldb_Block_h_
11 #define liblldb_Block_h_
17 // Other libraries and framework includes
19 #include "lldb/lldb-private.h"
20 #include "lldb/Core/AddressRange.h"
21 #include "lldb/Core/RangeMap.h"
22 #include "lldb/Core/Stream.h"
23 #include "lldb/Core/UserID.h"
24 #include "lldb/Symbol/LineEntry.h"
25 #include "lldb/Symbol/SymbolContext.h"
26 #include "lldb/Symbol/CompilerType.h"
28 namespace lldb_private {
30 //----------------------------------------------------------------------
31 /// @class Block Block.h "lldb/Symbol/Block.h"
32 /// @brief A class that describes a single lexical block.
34 /// A Function object owns a BlockList object which owns one or more
35 /// Block objects. The BlockList object contains a section offset
36 /// address range, and Block objects contain one or more ranges
37 /// which are offsets into that range. Blocks are can have discontiguous
38 /// ranges within the BlockList address range, and each block can
39 /// contain child blocks each with their own sets of ranges.
41 /// Each block has a variable list that represents local, argument, and
42 /// static variables that are scoped to the block.
44 /// Inlined functions are represented by attaching a
45 /// InlineFunctionInfo shared pointer object to a block. Inlined
46 /// functions are represented as named blocks.
47 //----------------------------------------------------------------------
50 public SymbolContextScope
53 typedef RangeArray<uint32_t, uint32_t, 1> RangeList;
54 typedef RangeList::Entry Range;
56 //------------------------------------------------------------------
57 /// Construct with a User ID \a uid, \a depth.
59 /// Initialize this block with the specified UID \a uid. The
60 /// \a depth in the \a block_list is used to represent the parent,
61 /// sibling, and child block information and also allows for partial
62 /// parsing at the block level.
65 /// The UID for a given block. This value is given by the
66 /// SymbolFile plug-in and can be any value that helps the
67 /// SymbolFile plug-in to match this block back to the debug
68 /// information data that it parses for further or more in
69 /// depth parsing. Common values would be the index into a
70 /// table, or an offset into the debug information.
73 /// The integer depth of this block in the block list hierarchy.
75 /// @param[in] block_list
76 /// The block list that this object belongs to.
79 //------------------------------------------------------------------
80 Block (lldb::user_id_t uid);
82 //------------------------------------------------------------------
84 //------------------------------------------------------------------
87 //------------------------------------------------------------------
88 /// Add a child to this object.
90 /// @param[in] child_block_sp
91 /// A shared pointer to a child block that will get added to
93 //------------------------------------------------------------------
95 AddChild (const lldb::BlockSP &child_block_sp);
97 //------------------------------------------------------------------
98 /// Add a new offset range to this block.
100 /// @param[in] start_offset
101 /// An offset into this Function's address range that
102 /// describes the start address of a range for this block.
104 /// @param[in] end_offset
105 /// An offset into this Function's address range that
106 /// describes the end address of a range for this block.
107 //------------------------------------------------------------------
109 AddRange (const Range& range);
114 //------------------------------------------------------------------
115 /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
117 /// @see SymbolContextScope
118 //------------------------------------------------------------------
120 CalculateSymbolContext(SymbolContext* sc) override;
123 CalculateSymbolContextModule() override;
126 CalculateSymbolContextCompileUnit() override;
129 CalculateSymbolContextFunction() override;
132 CalculateSymbolContextBlock() override;
134 //------------------------------------------------------------------
135 /// Check if an offset is in one of the block offset ranges.
137 /// @param[in] range_offset
138 /// An offset into the Function's address range.
141 /// Returns \b true if \a range_offset falls in one of this
142 /// block's ranges, \b false otherwise.
143 //------------------------------------------------------------------
145 Contains (lldb::addr_t range_offset) const;
147 //------------------------------------------------------------------
148 /// Check if a offset range is in one of the block offset ranges.
151 /// An offset range into the Function's address range.
154 /// Returns \b true if \a range falls in one of this
155 /// block's ranges, \b false otherwise.
156 //------------------------------------------------------------------
158 Contains (const Range& range) const;
160 //------------------------------------------------------------------
161 /// Check if this object contains "block" as a child block at any
165 /// A potential child block.
168 /// Returns \b true if \a block is a child of this block, \b
170 //------------------------------------------------------------------
172 Contains (const Block *block) const;
174 //------------------------------------------------------------------
175 /// Dump the block contents.
178 /// The stream to which to dump the object description.
180 /// @param[in] base_addr
181 /// The resolved start address of the Function's address
182 /// range. This should be resolved as the file or load address
183 /// prior to passing the value into this function for dumping.
186 /// Limit the number of levels deep that this function should
187 /// print as this block can contain child blocks. Specify
188 /// INT_MAX to dump all child blocks.
190 /// @param[in] show_context
191 /// If \b true, variables will dump their context information.
192 //------------------------------------------------------------------
194 Dump (Stream *s, lldb::addr_t base_addr, int32_t depth, bool show_context) const;
196 //------------------------------------------------------------------
197 /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
199 /// @see SymbolContextScope
200 //------------------------------------------------------------------
202 DumpSymbolContext(Stream *s) override;
205 DumpAddressRanges (Stream *s,
206 lldb::addr_t base_addr);
209 GetDescription (Stream *s,
211 lldb::DescriptionLevel level,
212 Target *target) const;
214 //------------------------------------------------------------------
215 /// Get the parent block.
218 /// The parent block pointer, or nullptr if this block has no
220 //------------------------------------------------------------------
224 //------------------------------------------------------------------
225 /// Get the inlined block that contains this block.
228 /// If this block contains inlined function info, it will return
229 /// this block, else parent blocks will be searched to see if
230 /// any contain this block. nullptr will be returned if this block
231 /// nor any parent blocks are inlined function blocks.
232 //------------------------------------------------------------------
234 GetContainingInlinedBlock ();
236 //------------------------------------------------------------------
237 /// Get the inlined parent block for this block.
240 /// The parent block pointer, or nullptr if this block has no
242 //------------------------------------------------------------------
246 //------------------------------------------------------------------
247 /// Get the sibling block for this block.
250 /// The sibling block pointer, or nullptr if this block has no
252 //------------------------------------------------------------------
256 //------------------------------------------------------------------
257 /// Get the first child block.
260 /// The first child block pointer, or nullptr if this block has no
262 //------------------------------------------------------------------
264 GetFirstChild () const
266 return (m_children.empty() ? nullptr : m_children.front().get());
269 //------------------------------------------------------------------
270 /// Get the variable list for this block only.
272 /// @param[in] can_create
273 /// If \b true, the variables can be parsed if they already
274 /// haven't been, else the current state of the block will be
278 /// A variable list shared pointer that contains all variables
280 //------------------------------------------------------------------
282 GetBlockVariableList (bool can_create);
284 //------------------------------------------------------------------
285 /// Get the variable list for this block and optionally all child
286 /// blocks if \a get_child_variables is \b true.
288 /// @param[in] get_child_variables
289 /// If \b true, all variables from all child blocks will be
290 /// added to the variable list.
292 /// @param[in] can_create
293 /// If \b true, the variables can be parsed if they already
294 /// haven't been, else the current state of the block will be
295 /// returned. Passing \b true for this parameter can be used
296 /// to see the current state of what has been parsed up to this
299 /// @param[in] add_inline_child_block_variables
300 /// If this is \b false, no child variables of child blocks
301 /// that are inlined functions will be gotten. If \b true then
302 /// all child variables will be added regardless of whether they
303 /// come from inlined functions or not.
306 /// A variable list shared pointer that contains all variables
308 //------------------------------------------------------------------
310 AppendBlockVariables (bool can_create,
311 bool get_child_block_variables,
312 bool stop_if_child_block_is_inlined_function,
313 const std::function<bool(Variable*)>& filter,
314 VariableList *variable_list);
316 //------------------------------------------------------------------
317 /// Appends the variables from this block, and optionally from all
318 /// parent blocks, to \a variable_list.
320 /// @param[in] can_create
321 /// If \b true, the variables can be parsed if they already
322 /// haven't been, else the current state of the block will be
323 /// returned. Passing \b true for this parameter can be used
324 /// to see the current state of what has been parsed up to this
327 /// @param[in] get_parent_variables
328 /// If \b true, all variables from all parent blocks will be
329 /// added to the variable list.
331 /// @param[in] stop_if_block_is_inlined_function
332 /// If \b true, all variables from all parent blocks will be
333 /// added to the variable list until there are no parent blocks
334 /// or the parent block has inlined function info.
336 /// @param[in,out] variable_list
337 /// All variables in this block, and optionally all parent
338 /// blocks will be added to this list.
341 /// The number of variable that were appended to \a
343 //------------------------------------------------------------------
345 AppendVariables (bool can_create,
346 bool get_parent_variables,
347 bool stop_if_block_is_inlined_function,
348 const std::function<bool(Variable*)>& filter,
349 VariableList *variable_list);
351 //------------------------------------------------------------------
352 /// Get const accessor for any inlined function information.
355 /// A const pointer to any inlined function information, or nullptr
356 /// if this is a regular block.
357 //------------------------------------------------------------------
358 const InlineFunctionInfo*
359 GetInlinedFunctionInfo () const
361 return m_inlineInfoSP.get();
367 //------------------------------------------------------------------
368 /// Get the memory cost of this object.
370 /// Returns the cost of this object plus any owned objects from the
371 /// ranges, variables, and inline function information.
374 /// The number of bytes that this object occupies in memory.
375 //------------------------------------------------------------------
379 //------------------------------------------------------------------
380 /// Set accessor for any inlined function information.
383 /// The method name for the inlined function. This value should
386 /// @param[in] mangled
387 /// The mangled method name for the inlined function. This can
388 /// be nullptr if there is no mangled name for an inlined function
389 /// or if the name is the same as \a name.
391 /// @param[in] decl_ptr
392 /// A optional pointer to declaration information for the
393 /// inlined function information. This value can be nullptr to
394 /// indicate that no declaration information is available.
396 /// @param[in] call_decl_ptr
397 /// Optional calling location declaration information that
398 /// describes from where this inlined function was called.
399 //------------------------------------------------------------------
401 SetInlinedFunctionInfo (const char *name,
403 const Declaration *decl_ptr,
404 const Declaration *call_decl_ptr);
407 SetParentScope (SymbolContextScope *parent_scope)
409 m_parent_scope = parent_scope;
412 //------------------------------------------------------------------
413 /// Set accessor for the variable list.
415 /// Called by the SymbolFile plug-ins after they have parsed the
416 /// variable lists and are ready to hand ownership of the list over
419 /// @param[in] variable_list_sp
420 /// A shared pointer to a VariableList.
421 //------------------------------------------------------------------
423 SetVariableList (lldb::VariableListSP& variable_list_sp)
425 m_variable_list_sp = variable_list_sp;
429 BlockInfoHasBeenParsed() const
431 return m_parsed_block_info;
435 SetBlockInfoHasBeenParsed (bool b, bool set_children);
438 FindBlockByID (lldb::user_id_t block_id);
441 GetNumRanges () const
443 return m_ranges.GetSize();
447 GetRangeContainingOffset (const lldb::addr_t offset, Range &range);
450 GetRangeContainingAddress (const Address& addr, AddressRange &range);
453 GetRangeContainingLoadAddress (lldb::addr_t load_addr, Target &target, AddressRange &range);
456 GetRangeIndexContainingAddress (const Address& addr);
458 //------------------------------------------------------------------
459 // Since blocks might have multiple discontiguous address ranges,
460 // we need to be able to get at any of the address ranges in a block.
461 //------------------------------------------------------------------
463 GetRangeAtIndex (uint32_t range_idx,
464 AddressRange &range);
467 GetStartAddress (Address &addr);
470 SetDidParseVariables (bool b, bool set_children);
473 typedef std::vector<lldb::BlockSP> collection;
474 //------------------------------------------------------------------
476 //------------------------------------------------------------------
477 SymbolContextScope *m_parent_scope;
478 collection m_children;
480 lldb::InlineFunctionInfoSP m_inlineInfoSP; ///< Inlined function information.
481 lldb::VariableListSP m_variable_list_sp; ///< The variable list for all local, static and parameter variables scoped to this block.
482 bool m_parsed_block_info:1, ///< Set to true if this block and it's children have all been parsed
483 m_parsed_block_variables:1,
484 m_parsed_child_blocks:1;
486 // A parent of child blocks can be asked to find a sibling block given
487 // one of its child blocks
489 GetSiblingForChild (const Block *child_block) const;
492 DISALLOW_COPY_AND_ASSIGN (Block);
495 } // namespace lldb_private
497 #endif // liblldb_Block_h_