| //===-- Function.h ----------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef liblldb_Function_h_ |
| #define liblldb_Function_h_ |
| |
| #include "lldb/Core/ClangForward.h" |
| #include "lldb/Core/AddressRange.h" |
| #include "lldb/Symbol/Block.h" |
| #include "lldb/Symbol/Declaration.h" |
| #include "lldb/Expression/DWARFExpression.h" |
| #include "lldb/Core/Mangled.h" |
| #include "lldb/Core/UserID.h" |
| |
| namespace lldb_private { |
| |
| //---------------------------------------------------------------------- |
| /// @class FunctionInfo Function.h "lldb/Symbol/Function.h" |
| /// @brief A class that contains generic function information. |
| /// |
| /// This provides generic function information that gets reused between |
| /// inline functions and function types. |
| //---------------------------------------------------------------------- |
| class FunctionInfo |
| { |
| public: |
| //------------------------------------------------------------------ |
| /// Construct with the function method name and optional declaration |
| /// information. |
| /// |
| /// @param[in] name |
| /// A C string name for the method name for this function. This |
| /// value should not be the mangled named, but the simple method |
| /// name. |
| /// |
| /// @param[in] decl_ptr |
| /// Optional declaration information that describes where the |
| /// function was declared. This can be NULL. |
| //------------------------------------------------------------------ |
| FunctionInfo (const char *name, const Declaration *decl_ptr); |
| |
| //------------------------------------------------------------------ |
| /// Construct with the function method name and optional declaration |
| /// information. |
| /// |
| /// @param[in] name |
| /// A name for the method name for this function. This value |
| /// should not be the mangled named, but the simple method name. |
| /// |
| /// @param[in] decl_ptr |
| /// Optional declaration information that describes where the |
| /// function was declared. This can be NULL. |
| //------------------------------------------------------------------ |
| FunctionInfo (const ConstString& name, const Declaration *decl_ptr); |
| |
| //------------------------------------------------------------------ |
| /// Destructor. |
| /// |
| /// The destructor is virtual since classes inherit from this class. |
| //------------------------------------------------------------------ |
| virtual |
| ~FunctionInfo (); |
| |
| //------------------------------------------------------------------ |
| /// Compare two function information objects. |
| /// |
| /// First compares the method names, and if equal, then compares |
| /// the declaration information. |
| /// |
| /// @param[in] lhs |
| /// The Left Hand Side const FunctionInfo object reference. |
| /// |
| /// @param[in] rhs |
| /// The Right Hand Side const FunctionInfo object reference. |
| /// |
| /// @return |
| /// @li -1 if lhs < rhs |
| /// @li 0 if lhs == rhs |
| /// @li 1 if lhs > rhs |
| //------------------------------------------------------------------ |
| static int |
| Compare (const FunctionInfo& lhs, const FunctionInfo& rhs); |
| |
| //------------------------------------------------------------------ |
| /// Dump a description of this object to a Stream. |
| /// |
| /// Dump a description of the contents of this object to the |
| /// supplied stream \a s. |
| /// |
| /// @param[in] s |
| /// The stream to which to dump the object description. |
| //------------------------------------------------------------------ |
| void |
| Dump (Stream *s, bool show_fullpaths) const; |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the declaration information. |
| /// |
| /// @return |
| /// A reference to the declaration object. |
| //------------------------------------------------------------------ |
| Declaration& |
| GetDeclaration (); |
| |
| //------------------------------------------------------------------ |
| /// Get const accessor for the declaration information. |
| /// |
| /// @return |
| /// A const reference to the declaration object. |
| //------------------------------------------------------------------ |
| const Declaration& |
| GetDeclaration () const; |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the method name. |
| /// |
| /// @return |
| /// A const reference to the method name object. |
| //------------------------------------------------------------------ |
| const ConstString& |
| GetName () const; |
| |
| //------------------------------------------------------------------ |
| /// Get the memory cost of this object. |
| /// |
| /// @return |
| /// The number of bytes that this object occupies in memory. |
| /// The returned value does not include the bytes for any |
| /// shared string values. |
| /// |
| /// @see ConstString::StaticMemorySize () |
| //------------------------------------------------------------------ |
| virtual size_t |
| MemorySize () const; |
| |
| protected: |
| //------------------------------------------------------------------ |
| // Member variables. |
| //------------------------------------------------------------------ |
| ConstString m_name; ///< Function method name (not a mangled name). |
| Declaration m_declaration; ///< Information describing where this function information was defined. |
| }; |
| |
| |
| //---------------------------------------------------------------------- |
| /// @class InlineFunctionInfo Function.h "lldb/Symbol/Function.h" |
| /// @brief A class that describes information for an inlined function. |
| //---------------------------------------------------------------------- |
| class InlineFunctionInfo : public FunctionInfo |
| { |
| public: |
| //------------------------------------------------------------------ |
| /// Construct with the function method name, mangled name, and |
| /// optional declaration information. |
| /// |
| /// @param[in] name |
| /// A C string name for the method name for this function. This |
| /// value should not be the mangled named, but the simple method |
| /// name. |
| /// |
| /// @param[in] mangled |
| /// A C string name for the mangled name for this function. This |
| /// value can be NULL if there is no mangled information. |
| /// |
| /// @param[in] decl_ptr |
| /// Optional declaration information that describes where the |
| /// function was declared. This can be NULL. |
| /// |
| /// @param[in] call_decl_ptr |
| /// Optional calling location declaration information that |
| /// describes from where this inlined function was called. |
| //------------------------------------------------------------------ |
| InlineFunctionInfo(const char *name, const char *mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr); |
| |
| //------------------------------------------------------------------ |
| /// Construct with the function method name, mangled name, and |
| /// optional declaration information. |
| /// |
| /// @param[in] name |
| /// A name for the method name for this function. This value |
| /// should not be the mangled named, but the simple method name. |
| /// |
| /// @param[in] mangled |
| /// A name for the mangled name for this function. This value |
| /// can be empty if there is no mangled information. |
| /// |
| /// @param[in] decl_ptr |
| /// Optional declaration information that describes where the |
| /// function was declared. This can be NULL. |
| /// |
| /// @param[in] call_decl_ptr |
| /// Optional calling location declaration information that |
| /// describes from where this inlined function was called. |
| //------------------------------------------------------------------ |
| InlineFunctionInfo(const ConstString& name, const Mangled &mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr); |
| |
| //------------------------------------------------------------------ |
| /// Destructor. |
| //------------------------------------------------------------------ |
| ~InlineFunctionInfo(); |
| |
| //------------------------------------------------------------------ |
| /// Compare two inlined function information objects. |
| /// |
| /// First compares the FunctionInfo objects, and if equal, |
| /// compares the mangled names. |
| /// |
| /// @param[in] lhs |
| /// The Left Hand Side const InlineFunctionInfo object |
| /// reference. |
| /// |
| /// @param[in] rhs |
| /// The Right Hand Side const InlineFunctionInfo object |
| /// reference. |
| /// |
| /// @return |
| /// @li -1 if lhs < rhs |
| /// @li 0 if lhs == rhs |
| /// @li 1 if lhs > rhs |
| //------------------------------------------------------------------ |
| int |
| Compare(const InlineFunctionInfo& lhs, const InlineFunctionInfo& rhs); |
| |
| //------------------------------------------------------------------ |
| /// Dump a description of this object to a Stream. |
| /// |
| /// Dump a description of the contents of this object to the |
| /// supplied stream \a s. |
| /// |
| /// @param[in] s |
| /// The stream to which to dump the object description. |
| //------------------------------------------------------------------ |
| void |
| Dump(Stream *s, bool show_fullpaths) const; |
| |
| void |
| DumpStopContext (Stream *s) const; |
| |
| const ConstString & |
| GetName () const; |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the call site declaration information. |
| /// |
| /// @return |
| /// A reference to the declaration object. |
| //------------------------------------------------------------------ |
| Declaration& |
| GetCallSite (); |
| |
| //------------------------------------------------------------------ |
| /// Get const accessor for the call site declaration information. |
| /// |
| /// @return |
| /// A const reference to the declaration object. |
| //------------------------------------------------------------------ |
| const Declaration& |
| GetCallSite () const; |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the mangled name object. |
| /// |
| /// @return |
| /// A reference to the mangled name object. |
| //------------------------------------------------------------------ |
| Mangled& |
| GetMangled(); |
| |
| //------------------------------------------------------------------ |
| /// Get const accessor for the mangled name object. |
| /// |
| /// @return |
| /// A const reference to the mangled name object. |
| //------------------------------------------------------------------ |
| const Mangled& |
| GetMangled() const; |
| |
| //------------------------------------------------------------------ |
| /// Get the memory cost of this object. |
| /// |
| /// @return |
| /// The number of bytes that this object occupies in memory. |
| /// The returned value does not include the bytes for any |
| /// shared string values. |
| /// |
| /// @see ConstString::StaticMemorySize () |
| //------------------------------------------------------------------ |
| virtual size_t |
| MemorySize() const; |
| |
| private: |
| //------------------------------------------------------------------ |
| // Member variables. |
| //------------------------------------------------------------------ |
| Mangled m_mangled; ///< Mangled inlined function name (can be empty if there is no mangled information). |
| Declaration m_call_decl; |
| }; |
| |
| //---------------------------------------------------------------------- |
| /// @class Function Function.h "lldb/Symbol/Function.h" |
| /// @brief A class that describes a function. |
| /// |
| /// Functions belong to CompileUnit objects (Function::m_comp_unit), |
| /// have unique user IDs (Function::UserID), know how to reconstruct |
| /// their symbol context (Function::SymbolContextScope), have a |
| /// specific function type (Function::m_type_uid), have a simple |
| /// method name (FunctionInfo::m_name), be declared at a specific |
| /// location (FunctionInfo::m_declaration), possibly have mangled |
| /// names (Function::m_mangled), an optional return type |
| /// (Function::m_type), and contains lexical blocks |
| /// (Function::m_blocks). |
| /// |
| /// The function information is split into a few pieces: |
| /// @li The concrete instance information |
| /// @li The abstract information |
| /// |
| /// The abstract information is found in the function type (Type) that |
| /// describes a function information, return type and parameter types. |
| /// |
| /// The concrete information is the address range information and |
| /// specific locations for an instance of this function. |
| //---------------------------------------------------------------------- |
| class Function : |
| public UserID, |
| public SymbolContextScope |
| { |
| public: |
| //------------------------------------------------------------------ |
| /// Construct with a compile unit, function UID, function type UID, |
| /// optional mangled name, function type, and a section offset |
| /// based address range. |
| /// |
| /// @param[in] comp_unit |
| /// The compile unit to which this function belongs. |
| /// |
| /// @param[in] func_uid |
| /// The UID for this function. This value is provided by the |
| /// SymbolFile plug-in and can be any value that allows |
| /// the plug-in to quickly find and parse more detailed |
| /// information when and if more information is needed. |
| /// |
| /// @param[in] func_type_uid |
| /// The type UID for the function Type to allow for lazy type |
| /// parsing from the debug information. |
| /// |
| /// @param[in] mangled |
| /// The optional mangled name for this function. If empty, there |
| /// is no mangled information. |
| /// |
| /// @param[in] func_type |
| /// The optional function type. If NULL, the function type will |
| /// be parsed on demand when accessed using the |
| /// Function::GetType() function by asking the SymbolFile |
| /// plug-in to get the type for \a func_type_uid. |
| /// |
| /// @param[in] range |
| /// The section offset based address for this function. |
| //------------------------------------------------------------------ |
| Function ( |
| CompileUnit *comp_unit, |
| lldb::user_id_t func_uid, |
| lldb::user_id_t func_type_uid, |
| const Mangled &mangled, |
| Type * func_type, |
| const AddressRange& range); |
| |
| //------------------------------------------------------------------ |
| /// Construct with a compile unit, function UID, function type UID, |
| /// optional mangled name, function type, and a section offset |
| /// based address range. |
| /// |
| /// @param[in] comp_unit |
| /// The compile unit to which this function belongs. |
| /// |
| /// @param[in] func_uid |
| /// The UID for this function. This value is provided by the |
| /// SymbolFile plug-in and can be any value that allows |
| /// the plug-in to quickly find and parse more detailed |
| /// information when and if more information is needed. |
| /// |
| /// @param[in] func_type_uid |
| /// The type UID for the function Type to allow for lazy type |
| /// parsing from the debug information. |
| /// |
| /// @param[in] mangled |
| /// The optional mangled name for this function. If empty, there |
| /// is no mangled information. |
| /// |
| /// @param[in] func_type |
| /// The optional function type. If NULL, the function type will |
| /// be parsed on demand when accessed using the |
| /// Function::GetType() function by asking the SymbolFile |
| /// plug-in to get the type for \a func_type_uid. |
| /// |
| /// @param[in] range |
| /// The section offset based address for this function. |
| //------------------------------------------------------------------ |
| Function ( |
| CompileUnit *comp_unit, |
| lldb::user_id_t func_uid, |
| lldb::user_id_t func_type_uid, |
| const char *mangled, |
| Type * func_type, |
| const AddressRange& range); |
| |
| //------------------------------------------------------------------ |
| /// Destructor. |
| //------------------------------------------------------------------ |
| ~Function (); |
| |
| //------------------------------------------------------------------ |
| /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) |
| /// |
| /// @see SymbolContextScope |
| //------------------------------------------------------------------ |
| virtual void |
| CalculateSymbolContext(SymbolContext* sc); |
| |
| virtual lldb::ModuleSP |
| CalculateSymbolContextModule (); |
| |
| virtual CompileUnit * |
| CalculateSymbolContextCompileUnit (); |
| |
| virtual Function * |
| CalculateSymbolContextFunction (); |
| |
| const AddressRange & |
| GetAddressRange() |
| { |
| return m_range; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Find the file and line number of the source location of the start |
| /// of the function. This will use the declaration if present and fall |
| /// back on the line table if that fails. So there may NOT be a line |
| /// table entry for this source file/line combo. |
| /// |
| /// @param[out] source_file |
| /// The source file. |
| /// |
| /// @param[out] line_no |
| /// The line number. |
| //------------------------------------------------------------------ |
| void |
| GetStartLineSourceInfo (FileSpec &source_file, uint32_t &line_no); |
| |
| //------------------------------------------------------------------ |
| /// Find the file and line number of the source location of the end |
| /// of the function. |
| /// |
| /// |
| /// @param[out] source_file |
| /// The source file. |
| /// |
| /// @param[out] line_no |
| /// The line number. |
| //------------------------------------------------------------------ |
| void |
| GetEndLineSourceInfo (FileSpec &source_file, uint32_t &line_no); |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the block list. |
| /// |
| /// @return |
| /// The block list object that describes all lexical blocks |
| /// in the function. |
| /// |
| /// @see BlockList |
| //------------------------------------------------------------------ |
| Block& |
| GetBlock (bool can_create); |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the compile unit that owns this function. |
| /// |
| /// @return |
| /// A compile unit object pointer. |
| //------------------------------------------------------------------ |
| CompileUnit* |
| GetCompileUnit(); |
| |
| //------------------------------------------------------------------ |
| /// Get const accessor for the compile unit that owns this function. |
| /// |
| /// @return |
| /// A const compile unit object pointer. |
| //------------------------------------------------------------------ |
| const CompileUnit* |
| GetCompileUnit() const; |
| |
| void |
| GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target); |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the frame base location. |
| /// |
| /// @return |
| /// A location expression that describes the function frame |
| /// base. |
| //------------------------------------------------------------------ |
| DWARFExpression & |
| GetFrameBaseExpression() |
| { |
| return m_frame_base; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get const accessor for the frame base location. |
| /// |
| /// @return |
| /// A const compile unit object pointer. |
| //------------------------------------------------------------------ |
| const DWARFExpression & |
| GetFrameBaseExpression() const |
| { |
| return m_frame_base; |
| } |
| |
| const ConstString & |
| GetName() const |
| { |
| return m_mangled.GetName(); |
| } |
| |
| const Mangled & |
| GetMangled() const |
| { |
| return m_mangled; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get the DeclContext for this function, if available. |
| /// |
| /// @return |
| /// The DeclContext, or NULL if none exists. |
| //------------------------------------------------------------------ |
| clang::DeclContext * |
| GetClangDeclContext(); |
| |
| //------------------------------------------------------------------ |
| /// Get accessor for the type that describes the function |
| /// return value type, and parameter types. |
| /// |
| /// @return |
| /// A type object pointer. |
| //------------------------------------------------------------------ |
| Type* |
| GetType(); |
| |
| //------------------------------------------------------------------ |
| /// Get const accessor for the type that describes the function |
| /// return value type, and parameter types. |
| /// |
| /// @return |
| /// A const type object pointer. |
| //------------------------------------------------------------------ |
| const Type* |
| GetType() const; |
| |
| ClangASTType |
| GetClangType (); |
| |
| uint32_t |
| GetPrologueByteSize (); |
| |
| //------------------------------------------------------------------ |
| /// Dump a description of this object to a Stream. |
| /// |
| /// Dump a description of the contents of this object to the |
| /// supplied stream \a s. |
| /// |
| /// @param[in] s |
| /// The stream to which to dump the object description. |
| /// |
| /// @param[in] show_context |
| /// If \b true, variables will dump their symbol context |
| /// information. |
| //------------------------------------------------------------------ |
| void |
| Dump(Stream *s, bool show_context) const; |
| |
| //------------------------------------------------------------------ |
| /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*) |
| /// |
| /// @see SymbolContextScope |
| //------------------------------------------------------------------ |
| virtual void |
| DumpSymbolContext(Stream *s); |
| |
| //------------------------------------------------------------------ |
| /// Get the memory cost of this object. |
| /// |
| /// @return |
| /// The number of bytes that this object occupies in memory. |
| /// The returned value does not include the bytes for any |
| /// shared string values. |
| /// |
| /// @see ConstString::StaticMemorySize () |
| //------------------------------------------------------------------ |
| size_t |
| MemorySize () const; |
| |
| lldb::DisassemblerSP |
| GetInstructions (const ExecutionContext &exe_ctx, |
| const char *flavor, |
| bool prefer_file_cache); |
| |
| bool |
| GetDisassembly (const ExecutionContext &exe_ctx, |
| const char *flavor, |
| bool prefer_file_cache, |
| Stream &strm); |
| |
| protected: |
| |
| enum |
| { |
| flagsCalculatedPrologueSize = (1 << 0) ///< Have we already tried to calculate the prologue size? |
| }; |
| |
| |
| |
| //------------------------------------------------------------------ |
| // Member variables. |
| //------------------------------------------------------------------ |
| CompileUnit *m_comp_unit; ///< The compile unit that owns this function. |
| lldb::user_id_t m_type_uid; ///< The user ID of for the prototype Type for this function. |
| Type * m_type; ///< The function prototype type for this function that include the function info (FunctionInfo), return type and parameters. |
| Mangled m_mangled; ///< The mangled function name if any, if empty, there is no mangled information. |
| Block m_block; ///< All lexical blocks contained in this function. |
| AddressRange m_range; ///< The function address range that covers the widest range needed to contain all blocks |
| DWARFExpression m_frame_base; ///< The frame base expression for variables that are relative to the frame pointer. |
| Flags m_flags; |
| uint32_t m_prologue_byte_size; ///< Compute the prologue size once and cache it |
| private: |
| DISALLOW_COPY_AND_ASSIGN(Function); |
| }; |
| |
| } // namespace lldb_private |
| |
| #endif // liblldb_Function_h_ |
