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