LLDB mainline
CompilerDecl.h
Go to the documentation of this file.
1//===-- CompilerDecl.h ------------------------------------------*- C++ -*-===//
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#ifndef LLDB_SYMBOL_COMPILERDECL_H
10#define LLDB_SYMBOL_COMPILERDECL_H
11
14#include "lldb/lldb-private.h"
15
16namespace lldb_private {
17
18/// Represents a generic declaration such as a function declaration.
19///
20/// This class serves as an abstraction for a declaration inside one of the
21/// TypeSystems implemented by the language plugins. It does not have any actual
22/// logic in it but only stores an opaque pointer and a pointer to the
23/// TypeSystem that gives meaning to this opaque pointer. All methods of this
24/// class should call their respective method in the TypeSystem interface and
25/// pass the opaque pointer along.
26///
27/// \see lldb_private::TypeSystem
29public:
30 // Constructors and Destructors
31 CompilerDecl() = default;
32
33 /// Creates a CompilerDecl with the given TypeSystem and opaque pointer.
34 ///
35 /// This constructor should only be called from the respective TypeSystem
36 /// implementation.
37 CompilerDecl(TypeSystem *type_system, void *decl)
38 : m_type_system(type_system), m_opaque_decl(decl) {}
39
40 // Tests
41
42 explicit operator bool() const { return IsValid(); }
43
44 bool operator<(const CompilerDecl &rhs) const {
46 return m_opaque_decl < rhs.m_opaque_decl;
47 return m_type_system < rhs.m_type_system;
48 }
49
50 bool IsValid() const {
51 return m_type_system != nullptr && m_opaque_decl != nullptr;
52 }
53
54 // Accessors
55
57
58 void *GetOpaqueDecl() const { return m_opaque_decl; }
59
60 void SetDecl(TypeSystem *type_system, void *decl) {
61 m_type_system = type_system;
62 m_opaque_decl = decl;
63 }
64
65 void Clear() {
66 m_type_system = nullptr;
67 m_opaque_decl = nullptr;
68 }
69
70 ConstString GetName() const;
71
73
75
76 // If this decl represents a function, return the return type
78
79 // If this decl represents a function, return the number of arguments for the
80 // function
81 size_t GetNumFunctionArguments() const;
82
83 // If this decl represents a function, return the argument type given a zero
84 // based argument index
85 CompilerType GetFunctionArgumentType(size_t arg_idx) const;
86
87 /// Populate a valid compiler context from the current declaration.
88 ///
89 /// \returns A valid vector of CompilerContext entries that describes
90 /// this declaration. The first entry in the vector is the parent of
91 /// the subsequent entry, so the topmost entry is the global namespace.
92 std::vector<lldb_private::CompilerContext> GetCompilerContext() const;
93
94private:
96 void *m_opaque_decl = nullptr;
97};
98
99bool operator==(const CompilerDecl &lhs, const CompilerDecl &rhs);
100bool operator!=(const CompilerDecl &lhs, const CompilerDecl &rhs);
101
102} // namespace lldb_private
103
104#endif // LLDB_SYMBOL_COMPILERDECL_H
Represents a generic declaration context in a program.
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
void * GetOpaqueDecl() const
Definition: CompilerDecl.h:58
ConstString GetMangledName() const
CompilerType GetFunctionArgumentType(size_t arg_idx) const
bool operator<(const CompilerDecl &rhs) const
Definition: CompilerDecl.h:44
CompilerType GetFunctionReturnType() const
CompilerDeclContext GetDeclContext() const
size_t GetNumFunctionArguments() const
void SetDecl(TypeSystem *type_system, void *decl)
Definition: CompilerDecl.h:60
ConstString GetName() const
TypeSystem * GetTypeSystem() const
Definition: CompilerDecl.h:56
CompilerDecl(TypeSystem *type_system, void *decl)
Creates a CompilerDecl with the given TypeSystem and opaque pointer.
Definition: CompilerDecl.h:37
std::vector< lldb_private::CompilerContext > GetCompilerContext() const
Populate a valid compiler context from the current declaration.
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
Interface for representing a type system.
Definition: TypeSystem.h:67
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
bool operator!=(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1028
bool operator==(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1022