1//===--- InterfaceStubFunctionsConsumer.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 "clang/AST/Mangle.h"
10#include "clang/AST/RecursiveASTVisitor.h"
11#include "clang/Basic/TargetInfo.h"
12#include "clang/Frontend/CompilerInstance.h"
13#include "clang/Frontend/FrontendActions.h"
14#include "llvm/BinaryFormat/ELF.h"
15
16using namespace clang;
17
18namespace {
19class InterfaceStubFunctionsConsumer : public ASTConsumer {
20 CompilerInstance &Instance;
21 StringRef InFile;
22 StringRef Format;
23 std::set<std::string> ParsedTemplates;
24
25 enum RootDeclOrigin { TopLevel = 0, FromTU = 1, IsLate = 2 };
26 struct MangledSymbol {
27 std::string ParentName;
28 uint8_t Type;
29 uint8_t Binding;
30 std::vector<std::string> Names;
31 MangledSymbol() = delete;
32
33 MangledSymbol(const std::string &ParentName, uint8_t Type, uint8_t Binding,
34 std::vector<std::string> Names)
35 : ParentName(ParentName), Type(Type), Binding(Binding),
36 Names(std::move(Names)) {}
37 };
38 using MangledSymbols = std::map<const NamedDecl *, MangledSymbol>;
39
40 bool WriteNamedDecl(const NamedDecl *ND, MangledSymbols &Symbols, int RDO) {
41 // Here we filter out anything that's not set to DefaultVisibility.
42 // DefaultVisibility is set on a decl when -fvisibility is not specified on
43 // the command line (or specified as default) and the decl does not have
44 // __attribute__((visibility("hidden"))) set or when the command line
45 // argument is set to hidden but the decl explicitly has
46 // __attribute__((visibility ("default"))) set. We do this so that the user
47 // can have fine grain control of what they want to expose in the stub.
48 auto isVisible = [](const NamedDecl *ND) -> bool {
49 return ND->getVisibility() == DefaultVisibility;
50 };
51
52 auto ignoreDecl = [this, isVisible](const NamedDecl *ND) -> bool {
53 if (!isVisible(ND))
54 return true;
55
56 if (const VarDecl *VD = dyn_cast<VarDecl>(Val: ND)) {
57 if (const auto *Parent = VD->getParentFunctionOrMethod())
58 if (isa<BlockDecl>(Val: Parent) || isa<CXXMethodDecl>(Val: Parent))
59 return true;
60
61 if ((VD->getStorageClass() == StorageClass::SC_Extern) ||
62 (VD->getStorageClass() == StorageClass::SC_Static &&
63 VD->getParentFunctionOrMethod() == nullptr))
64 return true;
65 }
66
67 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Val: ND)) {
68 if (FD->isInlined() && !isa<CXXMethodDecl>(Val: FD) &&
69 !Instance.getLangOpts().GNUInline)
70 return true;
71 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Val: FD)) {
72 const CXXRecordDecl *RC = MD->getParent();
73 if (isa<ClassTemplateDecl>(Val: RC->getParent()) || !isVisible(RC))
74 return true;
75 if (MD->isDependentContext() || !MD->hasBody())
76 return true;
77 }
78 if (FD->getStorageClass() == StorageClass::SC_Static)
79 return true;
80 }
81 return false;
82 };
83
84 auto getParentFunctionDecl = [](const NamedDecl *ND) -> const NamedDecl * {
85 if (const VarDecl *VD = dyn_cast<VarDecl>(Val: ND))
86 if (const auto *FD =
87 dyn_cast_or_null<FunctionDecl>(Val: VD->getParentFunctionOrMethod()))
88 return FD;
89 return nullptr;
90 };
91
92 auto getMangledNames = [](const NamedDecl *ND) -> std::vector<std::string> {
93 if (!ND)
94 return {""};
95 ASTNameGenerator NameGen(ND->getASTContext());
96 std::vector<std::string> MangledNames = NameGen.getAllManglings(D: ND);
97 if (isa<CXXConstructorDecl>(Val: ND) || isa<CXXDestructorDecl>(Val: ND))
98 return MangledNames;
99#ifdef EXPENSIVE_CHECKS
100 assert(MangledNames.size() <= 1 && "Expected only one name mangling.");
101#endif
102 return {NameGen.getName(D: ND)};
103 };
104
105 if (!(RDO & FromTU))
106 return true;
107 if (Symbols.find(x: ND) != Symbols.end())
108 return true;
109 // - Currently have not figured out how to produce the names for FieldDecls.
110 // - Do not want to produce symbols for function paremeters.
111 if (isa<FieldDecl>(Val: ND) || isa<ParmVarDecl>(Val: ND))
112 return true;
113
114 const NamedDecl *ParentDecl = getParentFunctionDecl(ND);
115 if ((ParentDecl && ignoreDecl(ParentDecl)) || ignoreDecl(ND))
116 return true;
117
118 if (RDO & IsLate) {
119 Instance.getDiagnostics().Report(DiagID: diag::err_asm_invalid_type_in_input)
120 << "Generating Interface Stubs is not supported with "
121 "delayed template parsing.";
122 } else {
123 if (const auto *FD = dyn_cast<FunctionDecl>(Val: ND))
124 if (FD->isDependentContext())
125 return true;
126
127 const bool IsWeak = (ND->hasAttr<WeakAttr>() ||
128 ND->hasAttr<WeakRefAttr>() || ND->isWeakImported());
129
130 Symbols.insert(x: std::make_pair(
131 x&: ND,
132 y: MangledSymbol(getMangledNames(ParentDecl).front(),
133 // Type:
134 isa<VarDecl>(Val: ND) ? llvm::ELF::STT_OBJECT
135 : llvm::ELF::STT_FUNC,
136 // Binding:
137 IsWeak ? llvm::ELF::STB_WEAK : llvm::ELF::STB_GLOBAL,
138 getMangledNames(ND))));
139 }
140 return true;
141 }
142
143 void
144 HandleDecls(const llvm::iterator_range<DeclContext::decl_iterator> &Decls,
145 MangledSymbols &Symbols, int RDO) {
146 for (const auto *D : Decls)
147 HandleNamedDecl(ND: dyn_cast<NamedDecl>(Val: D), Symbols, RDO);
148 }
149
150 void HandleTemplateSpecializations(const FunctionTemplateDecl &FTD,
151 MangledSymbols &Symbols, int RDO) {
152 for (const auto *D : FTD.specializations())
153 HandleNamedDecl(ND: D, Symbols, RDO);
154 }
155
156 void HandleTemplateSpecializations(const ClassTemplateDecl &CTD,
157 MangledSymbols &Symbols, int RDO) {
158 for (const auto *D : CTD.specializations())
159 HandleNamedDecl(ND: D, Symbols, RDO);
160 }
161
162 bool HandleNamedDecl(const NamedDecl *ND, MangledSymbols &Symbols, int RDO) {
163 if (!ND)
164 return false;
165
166 switch (ND->getKind()) {
167 default:
168 break;
169 case Decl::Kind::Namespace:
170 HandleDecls(Decls: cast<NamespaceDecl>(Val: ND)->decls(), Symbols, RDO);
171 return true;
172 case Decl::Kind::CXXRecord:
173 HandleDecls(Decls: cast<CXXRecordDecl>(Val: ND)->decls(), Symbols, RDO);
174 return true;
175 case Decl::Kind::ClassTemplateSpecialization:
176 HandleDecls(Decls: cast<ClassTemplateSpecializationDecl>(Val: ND)->decls(), Symbols,
177 RDO);
178 return true;
179 case Decl::Kind::ClassTemplate:
180 HandleTemplateSpecializations(CTD: *cast<ClassTemplateDecl>(Val: ND), Symbols, RDO);
181 return true;
182 case Decl::Kind::FunctionTemplate:
183 HandleTemplateSpecializations(FTD: *cast<FunctionTemplateDecl>(Val: ND), Symbols,
184 RDO);
185 return true;
186 case Decl::Kind::Record:
187 case Decl::Kind::Typedef:
188 case Decl::Kind::Enum:
189 case Decl::Kind::EnumConstant:
190 case Decl::Kind::TemplateTypeParm:
191 case Decl::Kind::NonTypeTemplateParm:
192 case Decl::Kind::CXXConversion:
193 case Decl::Kind::UnresolvedUsingValue:
194 case Decl::Kind::Using:
195 case Decl::Kind::UsingShadow:
196 case Decl::Kind::TypeAliasTemplate:
197 case Decl::Kind::TypeAlias:
198 case Decl::Kind::VarTemplate:
199 case Decl::Kind::VarTemplateSpecialization:
200 case Decl::Kind::UsingDirective:
201 case Decl::Kind::TemplateTemplateParm:
202 case Decl::Kind::ClassTemplatePartialSpecialization:
203 case Decl::Kind::IndirectField:
204 case Decl::Kind::ConstructorUsingShadow:
205 case Decl::Kind::CXXDeductionGuide:
206 case Decl::Kind::NamespaceAlias:
207 case Decl::Kind::UnresolvedUsingTypename:
208 return true;
209 case Decl::Kind::Var: {
210 // Bail on any VarDecl that either has no named symbol.
211 if (!ND->getIdentifier())
212 return true;
213 const auto *VD = cast<VarDecl>(Val: ND);
214 // Bail on any VarDecl that is a dependent or templated type.
215 if (VD->isTemplated() || VD->getType()->isDependentType())
216 return true;
217 if (WriteNamedDecl(ND, Symbols, RDO))
218 return true;
219 break;
220 }
221 case Decl::Kind::ParmVar:
222 case Decl::Kind::CXXMethod:
223 case Decl::Kind::CXXConstructor:
224 case Decl::Kind::CXXDestructor:
225 case Decl::Kind::Function:
226 case Decl::Kind::Field:
227 if (WriteNamedDecl(ND, Symbols, RDO))
228 return true;
229 }
230
231 // While interface stubs are in the development stage, it's probably best to
232 // catch anything that's not a VarDecl or Template/FunctionDecl.
233 Instance.getDiagnostics().Report(DiagID: diag::err_asm_invalid_type_in_input)
234 << "Expected a function or function template decl.";
235 return false;
236 }
237
238public:
239 InterfaceStubFunctionsConsumer(CompilerInstance &Instance, StringRef InFile,
240 StringRef Format)
241 : Instance(Instance), InFile(InFile), Format(Format) {}
242
243 void HandleTranslationUnit(ASTContext &context) override {
244 struct Visitor : public RecursiveASTVisitor<Visitor> {
245 bool VisitNamedDecl(NamedDecl *ND) {
246 if (const auto *FD = dyn_cast<FunctionDecl>(Val: ND))
247 if (FD->isLateTemplateParsed()) {
248 LateParsedDecls.insert(x: FD);
249 return true;
250 }
251
252 if (const auto *VD = dyn_cast<ValueDecl>(Val: ND)) {
253 ValueDecls.insert(x: VD);
254 return true;
255 }
256
257 NamedDecls.insert(x: ND);
258 return true;
259 }
260
261 std::set<const NamedDecl *> LateParsedDecls;
262 std::set<NamedDecl *> NamedDecls;
263 std::set<const ValueDecl *> ValueDecls;
264 } v;
265
266 v.TraverseDecl(D: context.getTranslationUnitDecl());
267
268 MangledSymbols Symbols;
269 auto OS = Instance.createDefaultOutputFile(/*Binary=*/false, BaseInput: InFile, Extension: "ifs");
270 if (!OS)
271 return;
272
273 if (Instance.getLangOpts().DelayedTemplateParsing) {
274 clang::Sema &S = Instance.getSema();
275 for (const auto *FD : v.LateParsedDecls) {
276 clang::LateParsedTemplate &LPT =
277 *S.LateParsedTemplateMap.find(Key: cast<FunctionDecl>(Val: FD))->second;
278 S.LateTemplateParser(S.OpaqueParser, LPT);
279 HandleNamedDecl(ND: FD, Symbols, RDO: (FromTU | IsLate));
280 }
281 }
282
283 for (const NamedDecl *ND : v.ValueDecls)
284 HandleNamedDecl(ND, Symbols, RDO: FromTU);
285 for (const NamedDecl *ND : v.NamedDecls)
286 HandleNamedDecl(ND, Symbols, RDO: FromTU);
287
288 auto writeIfsV1 = [this](const llvm::Triple &T,
289 const MangledSymbols &Symbols,
290 const ASTContext &context, StringRef Format,
291 raw_ostream &OS) -> void {
292 OS << "--- !" << Format << "\n";
293 OS << "IfsVersion: 3.0\n";
294 OS << "Target: " << T.str() << "\n";
295 OS << "Symbols:\n";
296 for (const auto &E : Symbols) {
297 const MangledSymbol &Symbol = E.second;
298 for (const auto &Name : Symbol.Names) {
299 OS << " - { Name: \""
300 << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
301 ? ""
302 : (Symbol.ParentName + "."))
303 << Name << "\", Type: ";
304 switch (Symbol.Type) {
305 default:
306 llvm_unreachable(
307 "clang -emit-interface-stubs: Unexpected symbol type.");
308 case llvm::ELF::STT_NOTYPE:
309 OS << "NoType";
310 break;
311 case llvm::ELF::STT_OBJECT: {
312 auto VD = cast<ValueDecl>(Val: E.first)->getType();
313 OS << "Object, Size: "
314 << context.getTypeSizeInChars(T: VD).getQuantity();
315 break;
316 }
317 case llvm::ELF::STT_FUNC:
318 OS << "Func";
319 break;
320 }
321 if (Symbol.Binding == llvm::ELF::STB_WEAK)
322 OS << ", Weak: true";
323 OS << " }\n";
324 }
325 }
326 OS << "...\n";
327 OS.flush();
328 };
329
330 assert(Format == "ifs-v1" && "Unexpected IFS Format.");
331 writeIfsV1(Instance.getTarget().getTriple(), Symbols, context, Format, *OS);
332 }
333};
334} // namespace
335
336std::unique_ptr<ASTConsumer>
337GenerateInterfaceStubsAction::CreateASTConsumer(CompilerInstance &CI,
338 StringRef InFile) {
339 return std::make_unique<InterfaceStubFunctionsConsumer>(args&: CI, args&: InFile, args: "ifs-v1");
340}
341