//===-- Function.h ----------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLDB_SYMBOL_FUNCTION_H #define LLDB_SYMBOL_FUNCTION_H #include "lldb/Core/AddressRange.h" #include "lldb/Core/Declaration.h" #include "lldb/Core/Mangled.h" #include "lldb/Expression/DWARFExpressionList.h" #include "lldb/Symbol/Block.h" #include "lldb/Utility/UserID.h" #include "llvm/ADT/ArrayRef.h" #include <mutex> namespace lldb_private { class ExecutionContext; /// \class FunctionInfo Function.h "lldb/Symbol/Function.h" /// A class that contains generic function information. /// /// This provides generic function information that gets reused between inline /// functions and function types. class FunctionInfo { … }; /// \class InlineFunctionInfo Function.h "lldb/Symbol/Function.h" /// A class that describes information for an inlined function. class InlineFunctionInfo : public FunctionInfo { … }; class Function; /// \class CallSiteParameter Function.h "lldb/Symbol/Function.h" /// /// Represent the locations of a parameter at a call site, both in the caller /// and in the callee. struct CallSiteParameter { … }; /// A vector of \c CallSiteParameter. CallSiteParameterArray; /// \class CallEdge Function.h "lldb/Symbol/Function.h" /// /// Represent a call made within a Function. This can be used to find a path /// in the call graph between two functions, or to evaluate DW_OP_entry_value. class CallEdge { … }; /// A direct call site. Used to represent call sites where the address of the /// callee is fixed (e.g. a function call in C in which the call target is not /// a function pointer). class DirectCallEdge : public CallEdge { … }; /// An indirect call site. Used to represent call sites where the address of /// the callee is not fixed, e.g. a call to a C++ virtual function (where the /// address is loaded out of a vtable), or a call to a function pointer in C. class IndirectCallEdge : public CallEdge { … }; /// \class Function Function.h "lldb/Symbol/Function.h" /// 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 { … }; } // namespace lldb_private #endif // LLDB_SYMBOL_FUNCTION_H