clang  9.0.0
InterfaceStubFunctionsConsumer.cpp
Go to the documentation of this file.
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"
14 #include "llvm/BinaryFormat/ELF.h"
15 
16 using namespace clang;
17 
19  CompilerInstance &Instance;
20  StringRef InFile;
21  StringRef Format;
22  std::set<std::string> ParsedTemplates;
23 
24  enum RootDeclOrigin { TopLevel = 0, FromTU = 1, IsLate = 2 };
25  struct MangledSymbol {
26  std::string ParentName;
27  uint8_t Type;
28  uint8_t Binding;
29  std::vector<std::string> Names;
30  MangledSymbol() = delete;
31 
32  MangledSymbol(const std::string &ParentName, uint8_t Type, uint8_t Binding,
33  std::vector<std::string> Names)
34  : ParentName(ParentName), Type(Type), Binding(Binding), Names(Names) {}
35  };
36  using MangledSymbols = std::map<const NamedDecl *, MangledSymbol>;
37 
38  bool WriteNamedDecl(const NamedDecl *ND, MangledSymbols &Symbols, int RDO) {
39  // Here we filter out anything that's not set to DefaultVisibility.
40  // DefaultVisibility is set on a decl when -fvisibility is not specified on
41  // the command line (or specified as default) and the decl does not have
42  // __attribute__((visibility("hidden"))) set or when the command line
43  // argument is set to hidden but the decl explicitly has
44  // __attribute__((visibility ("default"))) set. We do this so that the user
45  // can have fine grain control of what they want to expose in the stub.
46  auto isVisible = [](const NamedDecl *ND) -> bool {
47  return ND->getVisibility() == DefaultVisibility;
48  };
49 
50  auto ignoreDecl = [this, isVisible](const NamedDecl *ND) -> bool {
51  if (!isVisible(ND))
52  return true;
53 
54  if (const VarDecl *VD = dyn_cast<VarDecl>(ND))
55  if ((VD->getStorageClass() == StorageClass::SC_Extern) ||
56  (VD->getStorageClass() == StorageClass::SC_Static &&
57  VD->getParentFunctionOrMethod() == nullptr))
58  return true;
59 
60  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
61  if (FD->isInlined() && !isa<CXXMethodDecl>(FD) &&
62  !Instance.getLangOpts().GNUInline)
63  return true;
64  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
65  if (const auto *RC = dyn_cast<CXXRecordDecl>(MD->getParent()))
66  if (isa<ClassTemplateDecl>(RC->getParent()) || !isVisible(RC))
67  return true;
68  if (MD->isDependentContext() || !MD->hasBody())
69  return true;
70  }
71  if (FD->getStorageClass() == StorageClass::SC_Static)
72  return true;
73  }
74  return false;
75  };
76 
77  auto getParentFunctionDecl = [](const NamedDecl *ND) -> const NamedDecl * {
78  if (const VarDecl *VD = dyn_cast<VarDecl>(ND))
79  if (const auto *FD =
80  dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod()))
81  return FD;
82  return nullptr;
83  };
84 
85  auto getMangledNames = [](const NamedDecl *ND) -> std::vector<std::string> {
86  if (!ND)
87  return {""};
88  ASTNameGenerator NameGen(ND->getASTContext());
89  std::vector<std::string> MangledNames = NameGen.getAllManglings(ND);
90  if (isa<CXXConstructorDecl>(ND) || isa<CXXDestructorDecl>(ND))
91  return MangledNames;
92 #ifdef EXPENSIVE_CHECKS
93  assert(MangledNames.size() <= 1 && "Expected only one name mangling.");
94 #endif
95  return {NameGen.getName(ND)};
96  };
97 
98  if (!(RDO & FromTU))
99  return true;
100  if (Symbols.find(ND) != Symbols.end())
101  return true;
102  // - Currently have not figured out how to produce the names for FieldDecls.
103  // - Do not want to produce symbols for function paremeters.
104  if (isa<FieldDecl>(ND) || isa<ParmVarDecl>(ND))
105  return true;
106 
107  const NamedDecl *ParentDecl = getParentFunctionDecl(ND);
108  if ((ParentDecl && ignoreDecl(ParentDecl)) || ignoreDecl(ND))
109  return true;
110 
111  if (RDO & IsLate) {
112  Instance.getDiagnostics().Report(diag::err_asm_invalid_type_in_input)
113  << "Generating Interface Stubs is not supported with "
114  "delayed template parsing.";
115  } else {
116  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
117  if (FD->isDependentContext())
118  return true;
119 
120  const bool IsWeak = (ND->hasAttr<WeakAttr>() ||
121  ND->hasAttr<WeakRefAttr>() || ND->isWeakImported());
122 
123  Symbols.insert(std::make_pair(
124  ND,
125  MangledSymbol(getMangledNames(ParentDecl).front(),
126  // Type:
127  isa<VarDecl>(ND) ? llvm::ELF::STT_OBJECT
128  : llvm::ELF::STT_FUNC,
129  // Binding:
130  IsWeak ? llvm::ELF::STB_WEAK : llvm::ELF::STB_GLOBAL,
131  getMangledNames(ND))));
132  }
133  return true;
134  }
135 
136  void
137  HandleDecls(const llvm::iterator_range<DeclContext::decl_iterator> &Decls,
138  MangledSymbols &Symbols, int RDO) {
139  for (const auto *D : Decls)
140  HandleNamedDecl(dyn_cast<NamedDecl>(D), Symbols, RDO);
141  }
142 
143  void HandleTemplateSpecializations(const FunctionTemplateDecl &FTD,
144  MangledSymbols &Symbols, int RDO) {
145  for (const auto *D : FTD.specializations())
146  HandleNamedDecl(dyn_cast<NamedDecl>(D), Symbols, RDO);
147  }
148 
149  void HandleTemplateSpecializations(const ClassTemplateDecl &CTD,
150  MangledSymbols &Symbols, int RDO) {
151  for (const auto *D : CTD.specializations())
152  HandleNamedDecl(dyn_cast<NamedDecl>(D), Symbols, RDO);
153  }
154 
155  bool HandleNamedDecl(const NamedDecl *ND, MangledSymbols &Symbols, int RDO) {
156  if (!ND)
157  return false;
158 
159  switch (ND->getKind()) {
160  default:
161  break;
162  case Decl::Kind::Namespace:
163  HandleDecls(cast<NamespaceDecl>(ND)->decls(), Symbols, RDO);
164  return true;
165  case Decl::Kind::CXXRecord:
166  HandleDecls(cast<CXXRecordDecl>(ND)->decls(), Symbols, RDO);
167  return true;
168  case Decl::Kind::ClassTemplateSpecialization:
169  HandleDecls(cast<ClassTemplateSpecializationDecl>(ND)->decls(), Symbols,
170  RDO);
171  return true;
172  case Decl::Kind::ClassTemplate:
173  HandleTemplateSpecializations(*cast<ClassTemplateDecl>(ND), Symbols, RDO);
174  return true;
175  case Decl::Kind::FunctionTemplate:
176  HandleTemplateSpecializations(*cast<FunctionTemplateDecl>(ND), Symbols,
177  RDO);
178  return true;
179  case Decl::Kind::TemplateTypeParm:
180  return true;
181  case Decl::Kind::Var:
182  case Decl::Kind::ParmVar:
183  case Decl::Kind::CXXMethod:
184  case Decl::Kind::CXXConstructor:
185  case Decl::Kind::CXXDestructor:
187  case Decl::Kind::Field:
188  if (WriteNamedDecl(ND, Symbols, RDO))
189  return true;
190  }
191 
192  // While interface stubs are in the development stage, it's probably best to
193  // catch anything that's not a VarDecl or Template/FunctionDecl.
194  Instance.getDiagnostics().Report(diag::err_asm_invalid_type_in_input)
195  << "Expected a function or function template decl.";
196  return false;
197  }
198 
199 public:
201  StringRef Format)
202  : Instance(Instance), InFile(InFile), Format(Format) {}
203 
204  void HandleTranslationUnit(ASTContext &context) override {
205  struct Visitor : public RecursiveASTVisitor<Visitor> {
206  bool VisitNamedDecl(NamedDecl *ND) {
207  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
208  if (FD->isLateTemplateParsed()) {
209  LateParsedDecls.insert(FD);
210  return true;
211  }
212 
213  if (const auto *VD = dyn_cast<ValueDecl>(ND)) {
214  ValueDecls.insert(VD);
215  return true;
216  }
217 
218  NamedDecls.insert(ND);
219  return true;
220  }
221 
222  std::set<const NamedDecl *> LateParsedDecls;
223  std::set<NamedDecl *> NamedDecls;
224  std::set<const ValueDecl *> ValueDecls;
225  } v;
226 
227  v.TraverseDecl(context.getTranslationUnitDecl());
228 
229  MangledSymbols Symbols;
230  auto OS = Instance.createDefaultOutputFile(/*Binary=*/false, InFile, "ifs");
231  if (!OS)
232  return;
233 
234  if (Instance.getLangOpts().DelayedTemplateParsing) {
235  clang::Sema &S = Instance.getSema();
236  for (const auto *FD : v.LateParsedDecls) {
238  *S.LateParsedTemplateMap.find(cast<FunctionDecl>(FD))->second;
240  HandleNamedDecl(FD, Symbols, (FromTU | IsLate));
241  }
242  }
243 
244  for (const NamedDecl *ND : v.ValueDecls)
245  HandleNamedDecl(ND, Symbols, FromTU);
246  for (const NamedDecl *ND : v.NamedDecls)
247  HandleNamedDecl(ND, Symbols, FromTU);
248 
249  auto writeIfoYaml = [this](const llvm::Triple &T,
250  const MangledSymbols &Symbols,
251  const ASTContext &context, StringRef Format,
252  raw_ostream &OS) -> void {
253  OS << "--- !" << Format << "\n";
254  OS << "FileHeader:\n";
255  OS << " Class: ELFCLASS";
256  OS << (T.isArch64Bit() ? "64" : "32");
257  OS << "\n";
258  OS << " Data: ELFDATA2";
259  OS << (T.isLittleEndian() ? "LSB" : "MSB");
260  OS << "\n";
261  OS << " Type: ET_REL\n";
262  OS << " Machine: "
263  << llvm::StringSwitch<llvm::StringRef>(T.getArchName())
264  .Case("x86_64", "EM_X86_64")
265  .Case("i386", "EM_386")
266  .Case("i686", "EM_386")
267  .Case("aarch64", "EM_AARCH64")
268  .Case("amdgcn", "EM_AMDGPU")
269  .Case("r600", "EM_AMDGPU")
270  .Case("arm", "EM_ARM")
271  .Case("thumb", "EM_ARM")
272  .Case("avr", "EM_AVR")
273  .Case("mips", "EM_MIPS")
274  .Case("mipsel", "EM_MIPS")
275  .Case("mips64", "EM_MIPS")
276  .Case("mips64el", "EM_MIPS")
277  .Case("msp430", "EM_MSP430")
278  .Case("ppc", "EM_PPC")
279  .Case("ppc64", "EM_PPC64")
280  .Case("ppc64le", "EM_PPC64")
281  .Case("x86", T.isOSIAMCU() ? "EM_IAMCU" : "EM_386")
282  .Case("x86_64", "EM_X86_64")
283  .Default("EM_NONE")
284  << "\nSymbols:\n";
285  for (const auto &E : Symbols) {
286  const MangledSymbol &Symbol = E.second;
287  for (auto Name : Symbol.Names) {
288  OS << " - Name: "
289  << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
290  ? ""
291  : (Symbol.ParentName + "."))
292  << Name << "\n"
293  << " Type: STT_";
294  switch (Symbol.Type) {
295  default:
296  case llvm::ELF::STT_NOTYPE:
297  OS << "NOTYPE";
298  break;
299  case llvm::ELF::STT_OBJECT:
300  OS << "OBJECT";
301  break;
302  case llvm::ELF::STT_FUNC:
303  OS << "FUNC";
304  break;
305  }
306  OS << "\n Binding: STB_"
307  << ((Symbol.Binding == llvm::ELF::STB_WEAK) ? "WEAK" : "GLOBAL")
308  << "\n";
309  }
310  }
311  OS << "...\n";
312  OS.flush();
313  };
314 
315  auto writeIfoElfAbiYaml =
316  [this](const llvm::Triple &T, const MangledSymbols &Symbols,
317  const ASTContext &context, StringRef Format,
318  raw_ostream &OS) -> void {
319  OS << "--- !" << Format << "\n";
320  OS << "TbeVersion: 1.0\n";
321  OS << "Arch: " << T.getArchName() << "\n";
322  OS << "Symbols:\n";
323  for (const auto &E : Symbols) {
324  const MangledSymbol &Symbol = E.second;
325  for (auto Name : Symbol.Names) {
326  OS << " "
327  << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
328  ? ""
329  : (Symbol.ParentName + "."))
330  << Name << ": { Type: ";
331  switch (Symbol.Type) {
332  default:
333  llvm_unreachable(
334  "clang -emit-iterface-stubs: Unexpected symbol type.");
335  case llvm::ELF::STT_NOTYPE:
336  OS << "NoType";
337  break;
338  case llvm::ELF::STT_OBJECT: {
339  auto VD = cast<ValueDecl>(E.first)->getType();
340  OS << "Object, Size: "
341  << context.getTypeSizeInChars(VD).getQuantity();
342  break;
343  }
344  case llvm::ELF::STT_FUNC:
345  OS << "Func";
346  break;
347  }
348  if (Symbol.Binding == llvm::ELF::STB_WEAK)
349  OS << ", Weak: true";
350  OS << " }\n";
351  }
352  }
353  OS << "...\n";
354  OS.flush();
355  };
356 
357  if (Format == "experimental-yaml-elf-v1")
358  writeIfoYaml(Instance.getTarget().getTriple(), Symbols, context, Format,
359  *OS);
360  else
361  writeIfoElfAbiYaml(Instance.getTarget().getTriple(), Symbols, context,
362  Format, *OS);
363  }
364 };
365 
366 std::unique_ptr<ASTConsumer>
368  StringRef InFile) {
369  return llvm::make_unique<InterfaceStubFunctionsConsumer>(
370  CI, InFile, "experimental-yaml-elf-v1");
371 }
372 
373 std::unique_ptr<ASTConsumer>
375  StringRef InFile) {
376  return llvm::make_unique<InterfaceStubFunctionsConsumer>(
377  CI, InFile, "experimental-tapi-elf-v1");
378 }
LangOptions & getLangOpts()
Represents a function declaration or definition.
Definition: Decl.h:1748
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:693
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
LateParsedTemplateMapT LateParsedTemplateMap
Definition: Sema.h:688
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:985
spec_range specializations() const
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
The base class of the type hierarchy.
Definition: Type.h:1433
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1297
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
Represents a variable declaration or definition.
Definition: Decl.h:812
InterfaceStubFunctionsConsumer(CompilerInstance &Instance, StringRef InFile, StringRef Format)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:45
spec_range specializations() const
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
bool hasAttr() const
Definition: DeclBase.h:542
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
do v
Definition: arm_acle.h:64
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2114
std::vector< std::string > getAllManglings(const Decl *D)
Definition: Mangle.cpp:485
void HandleTranslationUnit(ASTContext &context) override
HandleTranslationUnit - This method is called when the ASTs for entire translation unit have been par...
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:669
Dataflow Directional Tag Classes.
Kind getKind() const
Definition: DeclBase.h:432
TargetInfo & getTarget() const
void * OpaqueParser
Definition: Sema.h:695
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation&#39;s options) and add it to the list of tracked outp...
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1007
Declaration of a class template.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:390
Contains a late templated function.
Definition: Sema.h:11313
This represents a decl that may have a name.
Definition: Decl.h:248
Declaration of a template function.