LLDB  mainline
NameSearchContext.cpp
Go to the documentation of this file.
1 //===-- NameSearchContext.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 "NameSearchContext.h"
10 #include "ClangUtil.h"
11 
12 using namespace clang;
13 using namespace lldb_private;
14 
15 clang::NamedDecl *NameSearchContext::AddVarDecl(const CompilerType &type) {
16  assert(type && "Type for variable must be valid!");
17 
18  if (!type.IsValid())
19  return nullptr;
20 
21  TypeSystemClang *lldb_ast =
22  llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
23  if (!lldb_ast)
24  return nullptr;
25 
26  IdentifierInfo *ii = m_decl_name.getAsIdentifierInfo();
27 
28  clang::ASTContext &ast = lldb_ast->getASTContext();
29 
30  clang::NamedDecl *Decl = VarDecl::Create(
31  ast, const_cast<DeclContext *>(m_decl_context), SourceLocation(),
32  SourceLocation(), ii, ClangUtil::GetQualType(type), nullptr, SC_Static);
33  m_decls.push_back(Decl);
34 
35  return Decl;
36 }
37 
38 clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
39  bool extern_c) {
40  assert(type && "Type for variable must be valid!");
41 
42  if (!type.IsValid())
43  return nullptr;
44 
45  if (m_function_types.count(type))
46  return nullptr;
47 
48  TypeSystemClang *lldb_ast =
49  llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
50  if (!lldb_ast)
51  return nullptr;
52 
53  m_function_types.insert(type);
54 
55  QualType qual_type(ClangUtil::GetQualType(type));
56 
57  clang::ASTContext &ast = lldb_ast->getASTContext();
58 
59  const bool isInlineSpecified = false;
60  const bool hasWrittenPrototype = true;
61  const bool isConstexprSpecified = false;
62 
63  clang::DeclContext *context = const_cast<DeclContext *>(m_decl_context);
64 
65  if (extern_c) {
66  context = LinkageSpecDecl::Create(
67  ast, context, SourceLocation(), SourceLocation(),
68  clang::LinkageSpecDecl::LanguageIDs::lang_c, false);
69  }
70 
71  // Pass the identifier info for functions the decl_name is needed for
72  // operators
73  clang::DeclarationName decl_name =
74  m_decl_name.getNameKind() == DeclarationName::Identifier
75  ? m_decl_name.getAsIdentifierInfo()
76  : m_decl_name;
77 
78  clang::FunctionDecl *func_decl = FunctionDecl::Create(
79  ast, context, SourceLocation(), SourceLocation(), decl_name, qual_type,
80  nullptr, SC_Extern, isInlineSpecified, hasWrittenPrototype,
81  isConstexprSpecified ? ConstexprSpecKind::Constexpr
82  : ConstexprSpecKind::Unspecified);
83 
84  // We have to do more than just synthesize the FunctionDecl. We have to
85  // synthesize ParmVarDecls for all of the FunctionDecl's arguments. To do
86  // this, we raid the function's FunctionProtoType for types.
87 
88  const FunctionProtoType *func_proto_type =
89  qual_type.getTypePtr()->getAs<FunctionProtoType>();
90 
91  if (func_proto_type) {
92  unsigned NumArgs = func_proto_type->getNumParams();
93  unsigned ArgIndex;
94 
95  SmallVector<ParmVarDecl *, 5> parm_var_decls;
96 
97  for (ArgIndex = 0; ArgIndex < NumArgs; ++ArgIndex) {
98  QualType arg_qual_type(func_proto_type->getParamType(ArgIndex));
99 
100  parm_var_decls.push_back(
101  ParmVarDecl::Create(ast, const_cast<DeclContext *>(context),
102  SourceLocation(), SourceLocation(), nullptr,
103  arg_qual_type, nullptr, SC_Static, nullptr));
104  }
105 
106  func_decl->setParams(ArrayRef<ParmVarDecl *>(parm_var_decls));
107  } else {
109 
110  LLDB_LOG(log, "Function type wasn't a FunctionProtoType");
111  }
112 
113  // If this is an operator (e.g. operator new or operator==), only insert the
114  // declaration we inferred from the symbol if we can provide the correct
115  // number of arguments. We shouldn't really inject random decl(s) for
116  // functions that are analyzed semantically in a special way, otherwise we
117  // will crash in clang.
118  clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
119  if (func_proto_type &&
120  TypeSystemClang::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
121  if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
122  false, op_kind, func_proto_type->getNumParams()))
123  return nullptr;
124  }
125  m_decls.push_back(func_decl);
126 
127  return func_decl;
128 }
129 
130 clang::NamedDecl *NameSearchContext::AddGenericFunDecl() {
131  FunctionProtoType::ExtProtoInfo proto_info;
132 
133  proto_info.Variadic = true;
134 
135  QualType generic_function_type(
136  GetASTContext().getFunctionType(GetASTContext().UnknownAnyTy, // result
137  ArrayRef<QualType>(), // argument types
138  proto_info));
139 
140  return AddFunDecl(m_clang_ts.GetType(generic_function_type), true);
141 }
142 
143 clang::NamedDecl *
144 NameSearchContext::AddTypeDecl(const CompilerType &clang_type) {
145  if (ClangUtil::IsClangType(clang_type)) {
146  QualType qual_type = ClangUtil::GetQualType(clang_type);
147 
148  if (const TypedefType *typedef_type =
149  llvm::dyn_cast<TypedefType>(qual_type)) {
150  TypedefNameDecl *typedef_name_decl = typedef_type->getDecl();
151 
152  m_decls.push_back(typedef_name_decl);
153 
154  return (NamedDecl *)typedef_name_decl;
155  } else if (const TagType *tag_type = qual_type->getAs<TagType>()) {
156  TagDecl *tag_decl = tag_type->getDecl();
157 
158  m_decls.push_back(tag_decl);
159 
160  return tag_decl;
161  } else if (const ObjCObjectType *objc_object_type =
162  qual_type->getAs<ObjCObjectType>()) {
163  ObjCInterfaceDecl *interface_decl = objc_object_type->getInterface();
164 
165  m_decls.push_back((NamedDecl *)interface_decl);
166 
167  return (NamedDecl *)interface_decl;
168  }
169  }
170  return nullptr;
171 }
172 
173 void NameSearchContext::AddLookupResult(clang::DeclContextLookupResult result) {
174  for (clang::NamedDecl *decl : result)
175  m_decls.push_back(decl);
176 }
177 
178 void NameSearchContext::AddNamedDecl(clang::NamedDecl *decl) {
179  m_decls.push_back(decl);
180 }
lldb_private::TypeSystemClang::getASTContext
clang::ASTContext & getASTContext()
Returns the clang::ASTContext instance managed by this TypeSystemClang.
Definition: TypeSystemClang.cpp:693
ClangUtil.h
LIBLLDB_LOG_EXPRESSIONS
#define LIBLLDB_LOG_EXPRESSIONS
Definition: Logging.h:22
NameSearchContext.h
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
lldb_private::CompilerType::IsValid
bool IsValid() const
Definition: CompilerType.h:72
lldb_private::CompilerType::GetTypeSystem
TypeSystem * GetTypeSystem() const
Accessors.
Definition: CompilerType.h:162
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
clang
Definition: ASTResultSynthesizer.h:15
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::TypeSystemClang
A TypeSystem implementation based on Clang.
Definition: TypeSystemClang.h:106
lldb_private::Log
Definition: Log.h:49