This is an archive of the discontinued LLVM Phabricator instance.

Differential D76979

[clang][llvm] Interface Stubs new yaml file format changes.
ClosedPublic

Authored by plotfi on Mar 28 2020, 1:11 AM.

Details

Reviewers
compnerd
Commits
rGe3033c0ce551: [llvm][clang][IFS] Enhancing the llvm-ifs yaml format for symbol lists.
Summary

These file format changes have been a long time coming. Essentially instead of a yaml map mapping trait we now have a sequence. This generally makes the format work better for cases where the symbol list is empty.

Diff Detail

Event Timeline

plotfi created this revision.Mar 28 2020, 1:11 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 28 2020, 1:11 AM
Herald added subscribers: cfe-commits, kbarton, nemanjai. · View Herald Transcript
plotfi updated this revision to Diff 253314.Mar 28 2020, 1:13 AM

-U999

Herald added a subscriber: • wuzish. · View Herald TranscriptMar 28 2020, 1:13 AM
Harbormaster failed remote builds in B50788: Diff 253312!Mar 28 2020, 2:10 AM
Harbormaster failed remote builds in B50789: Diff 253314!
plotfi updated this revision to Diff 253360.Mar 28 2020, 10:15 AM

Changing some of the version checks. I don't think we need to have rigid checks considering this format is experimental.

compnerd added a comment.Mar 28 2020, 11:02 AM

Please address the linter warnings. I think that adding an additional test to demonstrate that the experimental-ifs-version-v1 is properly diagnosed is a good idea. LGTM other than that.

Harbormaster failed remote builds in B50818: Diff 253360!Mar 28 2020, 11:17 AM
plotfi updated this revision to Diff 253367.Mar 28 2020, 11:30 AM

fixing linter errors

plotfi updated this revision to Diff 253369.Mar 28 2020, 11:42 AM

Adding a better test to check the deprecated v1 format.

Harbormaster failed remote builds in B50824: Diff 253367!Mar 28 2020, 12:22 PM
Harbormaster failed remote builds in B50826: Diff 253369!
plotfi updated this revision to Diff 254075.Mar 31 2020, 7:20 PM

Updating to change im about to land, to see what precommit changes show.

Harbormaster failed remote builds in B51236: Diff 254075!Mar 31 2020, 8:23 PM
plotfi updated this revision to Diff 254080.Mar 31 2020, 8:39 PM

Trying to fix precommit / clang tidy checks.

Harbormaster completed remote builds in B51240: Diff 254080.Mar 31 2020, 9:27 PM
This revision was not accepted when it landed; it landed in state Needs Review.Apr 1 2020, 7:53 AM
Closed by commit rGe3033c0ce551: [llvm][clang][IFS] Enhancing the llvm-ifs yaml format for symbol lists. (authored by plotfi). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
include/
clang/
Frontend/
12 lines
2 lines
lib/
Driver/
ToolChains/
2 lines
Frontend/
13 lines
14 lines
FrontendTool/
4 lines
test/
InterfaceStubs/
15 lines
4 lines
4 lines
6 lines
6 lines
4 lines
4 lines
4 lines
8 lines
20 lines
2 lines
4 lines
4 lines
6 lines
4 lines
4 lines
4 lines
2 lines
12 lines
12 lines
4 lines
8 lines
4 lines
7 lines
4 lines
4 lines
6 lines
6 lines
12 lines
llvm/
test/
tools/
llvm-ifs/
Inputs/
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
8 lines
20 lines
15 lines
15 lines
20 lines
6 lines
6 lines
24 lines
12 lines
12 lines
6 lines
6 lines
6 lines
6 lines
16 lines
tools/
llvm-ifs/
41 lines

Diff 254202

clang/include/clang/Frontend/FrontendActions.h

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Linesprotected:
TranslationUnitKind getTranslationUnitKind() override { TranslationUnitKind getTranslationUnitKind() override {
return TU_Module; return TU_Module;
} }
bool hasASTFileSupport() const override { return false; } bool hasASTFileSupport() const override { return false; }
}; };
class GenerateInterfaceStubAction : public ASTFrontendAction { class GenerateInterfaceStubsAction : public ASTFrontendAction {
protected:
TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
bool hasASTFileSupport() const override { return false; }
};
class GenerateInterfaceIfsExpV1Action : public GenerateInterfaceStubAction {
protected: protected:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override; StringRef InFile) override;
TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
bool hasASTFileSupport() const override { return false; }
}; };
class GenerateModuleFromModuleMapAction : public GenerateModuleAction { class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
private: private:
bool BeginSourceFileAction(CompilerInstance &CI) override; bool BeginSourceFileAction(CompilerInstance &CI) override;
std::unique_ptr<raw_pwrite_stream> std::unique_ptr<raw_pwrite_stream>
CreateOutputFile(CompilerInstance &CI, StringRef InFile) override; CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

clang/include/clang/Frontend/FrontendOptions.h

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linesenum ActionKind {
/// Generate pre-compiled module from a set of header files. /// Generate pre-compiled module from a set of header files.
GenerateHeaderModule, GenerateHeaderModule,
/// Generate pre-compiled header. /// Generate pre-compiled header.
GeneratePCH, GeneratePCH,
/// Generate Interface Stub Files. /// Generate Interface Stub Files.
GenerateInterfaceIfsExpV1, GenerateInterfaceStubs,
/// Only execute frontend initialization. /// Only execute frontend initialization.
InitOnly, InitOnly,
/// Dump information about a module file. /// Dump information about a module file.
ModuleFileInfo, ModuleFileInfo,
/// Load and verify that a PCH file is usable. /// Load and verify that a PCH file is usable.
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

clang/lib/Driver/ToolChains/Clang.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,178 Lines • ▼ Show 20 Lines if (isa<AnalyzeJobAction>(JA)) {
} else if (JA.getType() == types::TY_LLVM_BC || } else if (JA.getType() == types::TY_LLVM_BC ||
JA.getType() == types::TY_LTO_BC) { JA.getType() == types::TY_LTO_BC) {
CmdArgs.push_back("-emit-llvm-bc"); CmdArgs.push_back("-emit-llvm-bc");
} else if (JA.getType() == types::TY_IFS || } else if (JA.getType() == types::TY_IFS ||
JA.getType() == types::TY_IFS_CPP) { JA.getType() == types::TY_IFS_CPP) {
StringRef ArgStr = StringRef ArgStr =
Args.hasArg(options::OPT_interface_stub_version_EQ) Args.hasArg(options::OPT_interface_stub_version_EQ)
? Args.getLastArgValue(options::OPT_interface_stub_version_EQ) ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
: "experimental-ifs-v1"; : "experimental-ifs-v2";
CmdArgs.push_back("-emit-interface-stubs"); CmdArgs.push_back("-emit-interface-stubs");
CmdArgs.push_back( CmdArgs.push_back(
Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str())); Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str()));
} else if (JA.getType() == types::TY_PP_Asm) { } else if (JA.getType() == types::TY_PP_Asm) {
CmdArgs.push_back("-S"); CmdArgs.push_back("-S");
} else if (JA.getType() == types::TY_AST) { } else if (JA.getType() == types::TY_AST) {
CmdArgs.push_back("-emit-pch"); CmdArgs.push_back("-emit-pch");
} else if (JA.getType() == types::TY_ModuleFile) { } else if (JA.getType() == types::TY_ModuleFile) {
▲ Show 20 Lines • Show All 2,942 Lines • Show Last 20 Lines

clang/lib/Frontend/CompilerInvocation.cpp

Show First 20 Lines • Show All 1,774 Lines • ▼ Show 20 Lines if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
case OPT_emit_header_module: case OPT_emit_header_module:
Opts.ProgramAction = frontend::GenerateHeaderModule; break; Opts.ProgramAction = frontend::GenerateHeaderModule; break;
case OPT_emit_pch: case OPT_emit_pch:
Opts.ProgramAction = frontend::GeneratePCH; break; Opts.ProgramAction = frontend::GeneratePCH; break;
case OPT_emit_interface_stubs: { case OPT_emit_interface_stubs: {
StringRef ArgStr = StringRef ArgStr =
Args.hasArg(OPT_interface_stub_version_EQ) Args.hasArg(OPT_interface_stub_version_EQ)
? Args.getLastArgValue(OPT_interface_stub_version_EQ) ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
: "experimental-ifs-v1"; : "experimental-ifs-v2";
if (ArgStr == "experimental-yaml-elf-v1" || if (ArgStr == "experimental-yaml-elf-v1" ||
ArgStr == "experimental-ifs-v1" ||
ArgStr == "experimental-tapi-elf-v1") { ArgStr == "experimental-tapi-elf-v1") {
std::string ErrorMessage = std::string ErrorMessage =
"Invalid interface stub format: " + ArgStr.str() + "Invalid interface stub format: " + ArgStr.str() +
" is deprecated."; " is deprecated.";
Diags.Report(diag::err_drv_invalid_value) Diags.Report(diag::err_drv_invalid_value)
<< "Must specify a valid interface stub format type, ie: " << "Must specify a valid interface stub format type, ie: "
"-interface-stub-version=experimental-ifs-v1" "-interface-stub-version=experimental-ifs-v2"
<< ErrorMessage; << ErrorMessage;
} else if (ArgStr != "experimental-ifs-v1") { } else if (!ArgStr.startswith("experimental-ifs-")) {
std::string ErrorMessage = std::string ErrorMessage =
"Invalid interface stub format: " + ArgStr.str() + "."; "Invalid interface stub format: " + ArgStr.str() + ".";
Diags.Report(diag::err_drv_invalid_value) Diags.Report(diag::err_drv_invalid_value)
<< "Must specify a valid interface stub format type, ie: " << "Must specify a valid interface stub format type, ie: "
"-interface-stub-version=experimental-ifs-v1" "-interface-stub-version=experimental-ifs-v2"
<< ErrorMessage; << ErrorMessage;
} else { } else {
Opts.ProgramAction = frontend::GenerateInterfaceIfsExpV1; Opts.ProgramAction = frontend::GenerateInterfaceStubs;
} }
break; break;
} }
case OPT_init_only: case OPT_init_only:
Opts.ProgramAction = frontend::InitOnly; break; Opts.ProgramAction = frontend::InitOnly; break;
case OPT_fsyntax_only: case OPT_fsyntax_only:
Opts.ProgramAction = frontend::ParseSyntaxOnly; break; Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
case OPT_module_file_info: case OPT_module_file_info:
▲ Show 20 Lines • Show All 1,552 Lines • ▼ Show 20 Linesstatic bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
case frontend::EmitLLVMOnly: case frontend::EmitLLVMOnly:
case frontend::EmitCodeGenOnly: case frontend::EmitCodeGenOnly:
case frontend::EmitObj: case frontend::EmitObj:
case frontend::FixIt: case frontend::FixIt:
case frontend::GenerateModule: case frontend::GenerateModule:
case frontend::GenerateModuleInterface: case frontend::GenerateModuleInterface:
case frontend::GenerateHeaderModule: case frontend::GenerateHeaderModule:
case frontend::GeneratePCH: case frontend::GeneratePCH:
case frontend::GenerateInterfaceIfsExpV1: case frontend::GenerateInterfaceStubs:
case frontend::ParseSyntaxOnly: case frontend::ParseSyntaxOnly:
case frontend::ModuleFileInfo: case frontend::ModuleFileInfo:
case frontend::VerifyPCH: case frontend::VerifyPCH:
case frontend::PluginAction: case frontend::PluginAction:
case frontend::RewriteObjC: case frontend::RewriteObjC:
case frontend::RewriteTest: case frontend::RewriteTest:
case frontend::RunAnalysis: case frontend::RunAnalysis:
case frontend::TemplightDump: case frontend::TemplightDump:
▲ Show 20 Lines • Show All 452 Lines • Show Last 20 Lines

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

Show First 20 Lines • Show All 284 Lines • ▼ Show 20 Lines void HandleTranslationUnit(ASTContext &context) override {
for (const NamedDecl *ND : v.NamedDecls) for (const NamedDecl *ND : v.NamedDecls)
HandleNamedDecl(ND, Symbols, FromTU); HandleNamedDecl(ND, Symbols, FromTU);
auto writeIfsV1 = [this](const llvm::Triple &T, auto writeIfsV1 = [this](const llvm::Triple &T,
const MangledSymbols &Symbols, const MangledSymbols &Symbols,
const ASTContext &context, StringRef Format, const ASTContext &context, StringRef Format,
raw_ostream &OS) -> void { raw_ostream &OS) -> void {
OS << "--- !" << Format << "\n"; OS << "--- !" << Format << "\n";
OS << "IfsVersion: 1.0\n"; OS << "IfsVersion: 2.0\n";
OS << "Triple: " << T.str() << "\n"; OS << "Triple: " << T.str() << "\n";
OS << "ObjectFileFormat: " OS << "ObjectFileFormat: "
<< "ELF" << "ELF"
<< "\n"; // TODO: For now, just ELF. << "\n"; // TODO: For now, just ELF.
OS << "Symbols:\n"; OS << "Symbols:\n";
for (const auto &E : Symbols) { for (const auto &E : Symbols) {
const MangledSymbol &Symbol = E.second; const MangledSymbol &Symbol = E.second;
for (auto Name : Symbol.Names) { for (auto Name : Symbol.Names) {
OS << " \"" OS << " - { Name: \""
<< (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
? "" ? ""
: (Symbol.ParentName + ".")) : (Symbol.ParentName + "."))
<< Name << "\" : { Type: "; << Name << "\", Type: ";
switch (Symbol.Type) { switch (Symbol.Type) {
default: default:
llvm_unreachable( llvm_unreachable(
"clang -emit-interface-stubs: Unexpected symbol type."); "clang -emit-interface-stubs: Unexpected symbol type.");
case llvm::ELF::STT_NOTYPE: case llvm::ELF::STT_NOTYPE:
OS << "NoType"; OS << "NoType";
break; break;
case llvm::ELF::STT_OBJECT: { case llvm::ELF::STT_OBJECT: {
Show All 10 Lines auto writeIfsV1 = [this](const llvm::Triple &T,
OS << ", Weak: true"; OS << ", Weak: true";
OS << " }\n"; OS << " }\n";
} }
} }
OS << "...\n"; OS << "...\n";
OS.flush(); OS.flush();
}; };
assert(Format == "experimental-ifs-v1" && "Unexpected IFS Format."); assert(Format == "experimental-ifs-v2" && "Unexpected IFS Format.");
writeIfsV1(Instance.getTarget().getTriple(), Symbols, context, Format, *OS); writeIfsV1(Instance.getTarget().getTriple(), Symbols, context, Format, *OS);
} }
}; };
} // namespace } // namespace
std::unique_ptr<ASTConsumer> std::unique_ptr<ASTConsumer>
GenerateInterfaceIfsExpV1Action::CreateASTConsumer(CompilerInstance &CI, GenerateInterfaceStubsAction::CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) { StringRef InFile) {
return std::make_unique<InterfaceStubFunctionsConsumer>( return std::make_unique<InterfaceStubFunctionsConsumer>(
CI, InFile, "experimental-ifs-v1"); CI, InFile, "experimental-ifs-v2");
} }

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 LinesCreateFrontendBaseAction(CompilerInstance &CI) {
case FixIt: return std::make_unique<FixItAction>(); case FixIt: return std::make_unique<FixItAction>();
case GenerateModule: case GenerateModule:
return std::make_unique<GenerateModuleFromModuleMapAction>(); return std::make_unique<GenerateModuleFromModuleMapAction>();
case GenerateModuleInterface: case GenerateModuleInterface:
return std::make_unique<GenerateModuleInterfaceAction>(); return std::make_unique<GenerateModuleInterfaceAction>();
case GenerateHeaderModule: case GenerateHeaderModule:
return std::make_unique<GenerateHeaderModuleAction>(); return std::make_unique<GenerateHeaderModuleAction>();
case GeneratePCH: return std::make_unique<GeneratePCHAction>(); case GeneratePCH: return std::make_unique<GeneratePCHAction>();
case GenerateInterfaceIfsExpV1: case GenerateInterfaceStubs:
return std::make_unique<GenerateInterfaceIfsExpV1Action>(); return std::make_unique<GenerateInterfaceStubsAction>();
case InitOnly: return std::make_unique<InitOnlyAction>(); case InitOnly: return std::make_unique<InitOnlyAction>();
case ParseSyntaxOnly: return std::make_unique<SyntaxOnlyAction>(); case ParseSyntaxOnly: return std::make_unique<SyntaxOnlyAction>();
case ModuleFileInfo: return std::make_unique<DumpModuleInfoAction>(); case ModuleFileInfo: return std::make_unique<DumpModuleInfoAction>();
case VerifyPCH: return std::make_unique<VerifyPCHAction>(); case VerifyPCH: return std::make_unique<VerifyPCHAction>();
case TemplightDump: return std::make_unique<TemplightDumpAction>(); case TemplightDump: return std::make_unique<TemplightDumpAction>();
case PluginAction: { case PluginAction: {
for (FrontendPluginRegistry::iterator it = for (FrontendPluginRegistry::iterator it =
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

clang/test/InterfaceStubs/bad-format.cpp

// RUN: not %clang -emit-interface-stubs -interface-stub-version=bad-format %s 2>&1 | \ // RUN: not %clang -emit-interface-stubs -interface-stub-version=bad-format %s 2>&1 | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: not %clang -emit-interface-stubs -interface-stub-version=experimental-tapi-elf-v1 %s 2>&1 | \ // RUN: not %clang -emit-interface-stubs -interface-stub-version=experimental-tapi-elf-v1 %s 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-TAPI-DEPRECATED %s // RUN: FileCheck -check-prefix=CHECK-TAPI-DEPRECATED %s
// RUN: not %clang -emit-interface-stubs -interface-stub-version=experimental-yaml-elf-v1 %s 2>&1 | \ // RUN: not %clang -emit-interface-stubs -interface-stub-version=experimental-yaml-elf-v1 %s 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-YAML-DEPRECATED %s // RUN: FileCheck -check-prefix=CHECK-YAML-DEPRECATED %s
// RUN: not %clang -emit-interface-stubs -interface-stub-version=experimental-ifs-v1 %s 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-V1-DEPRECATED %s
// RUN: not %clang -emit-interface-stubs -interface-stub-version=bad-format %s 2>&1 | \ // RUN: not %clang -emit-interface-stubs -interface-stub-version=bad-format %s 2>&1 | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: not %clang -emit-interface-stubs \ // RUN: not %clang -emit-interface-stubs \
// RUN: -interface-stub-version=experimental-tapi-elf-v1 %s 2>&1 | \ // RUN: -interface-stub-version=experimental-tapi-elf-v1 %s 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-TAPI-DEPRECATED %s // RUN: FileCheck -check-prefix=CHECK-TAPI-DEPRECATED %s
// RUN: not %clang -emit-interface-stubs \ // RUN: not %clang -emit-interface-stubs \
// RUN: -interface-stub-version=experimental-yaml-elf-v1 %s 2>&1 | \ // RUN: -interface-stub-version=experimental-yaml-elf-v1 %s 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-YAML-DEPRECATED %s // RUN: FileCheck -check-prefix=CHECK-YAML-DEPRECATED %s
// CHECK: error: invalid value // CHECK: error: invalid value
// CHECK: 'Invalid interface stub format: bad-format.' in 'Must specify a // CHECK: 'Invalid interface stub format: bad-format.' in 'Must specify a
// CHECK: valid interface stub format type, ie: // CHECK: valid interface stub format type, ie:
// CHECK: -interface-stub-version=experimental-ifs-v1' // CHECK: -interface-stub-version=experimental-ifs-v2'
// CHECK-TAPI-DEPRECATED: error: invalid value // CHECK-TAPI-DEPRECATED: error: invalid value
// CHECK-TAPI-DEPRECATED: 'Invalid interface stub format: // CHECK-TAPI-DEPRECATED: 'Invalid interface stub format:
// CHECK-TAPI-DEPRECATED: experimental-tapi-elf-v1 is deprecated.' in 'Must // CHECK-TAPI-DEPRECATED: experimental-tapi-elf-v1 is deprecated.' in 'Must
// CHECK-TAPI-DEPRECATED: specify a valid interface stub format type, ie: // CHECK-TAPI-DEPRECATED: specify a valid interface stub format type, ie:
// CHECK-TAPI-DEPRECATED: -interface-stub-version=experimental-ifs-v1' // CHECK-TAPI-DEPRECATED: -interface-stub-version=experimental-ifs-v2'
// CHECK-YAML-DEPRECATED: error: invalid value // CHECK-YAML-DEPRECATED: error: invalid value
// CHECK-YAML-DEPRECATED: 'Invalid interface stub format: // CHECK-YAML-DEPRECATED: 'Invalid interface stub format:
// CHECK-YAML-DEPRECATED: experimental-yaml-elf-v1 is deprecated.' in 'Must // CHECK-YAML-DEPRECATED: experimental-yaml-elf-v1 is deprecated.' in 'Must
// CHECK-YAML-DEPRECATED: specify a valid interface stub format type, ie: // CHECK-YAML-DEPRECATED: specify a valid interface stub format type, ie:
// CHECK-YAML-DEPRECATED: -interface-stub-version=experimental-ifs-v1' // CHECK-YAML-DEPRECATED: -interface-stub-version=experimental-ifs-v2'
// CHECK-V1-DEPRECATED: error: invalid value
// CHECK-V1-DEPRECATED: 'Invalid interface stub format:
// CHECK-V1-DEPRECATED: experimental-ifs-v1 is deprecated.' in 'Must
// CHECK-V1-DEPRECATED: specify a valid interface stub format type, ie:
// CHECK-V1-DEPRECATED: -interface-stub-version=experimental-ifs-v2'

clang/test/InterfaceStubs/blocks.c

// RUN: %clang_cc1 -emit-interface-stubs -fblocks -o - %s | FileCheck %s // RUN: %clang_cc1 -emit-interface-stubs -fblocks -o - %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
static void (^f)(void*) = ^(void* data) { int i; }; static void (^f)(void*) = ^(void* data) { int i; };

clang/test/InterfaceStubs/class-template-partial-specialization.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<typename> struct S7 { }; template<typename> struct S7 { };
template<typename T> struct S7<T&> { }; template<typename T> struct S7<T&> { };

clang/test/InterfaceStubs/conflict-type.ifs

# RUN: not %clang -emit-merged-ifs -emit-interface-stubs -o - %s %S/func.ifs 2>&1 | \ # RUN: not %clang -emit-merged-ifs -emit-interface-stubs -o - %s %S/func.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# Here we are testing to see if two symbols with identical names will fail to # Here we are testing to see if two symbols with identical names will fail to
# merge in conflict due to mismatched types. # merge in conflict due to mismatched types.
# CHECK-IFS: error: Interface Stub: Type Mismatch for a. # CHECK-IFS: error: Interface Stub: Type Mismatch for a.
# CHECK-IFS-NEXT: Filename: # CHECK-IFS-NEXT: Filename:
# CHECK-IFS-NEXT: Type Values: Object Func # CHECK-IFS-NEXT: Type Values: Object Func
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-linux-gnu Triple: x86_64-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Object, Size: 1 } - { Name: a, Type: Object, Size: 1 }
... ...

clang/test/InterfaceStubs/constructor-using-shadow.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
// ConstructorUsingShadowDecl // ConstructorUsingShadowDecl
struct Base { Base(int); }; struct Base { Base(int); };
struct Derived : public Base { using Base::Base; }; struct Derived : public Base { using Base::Base; };

clang/test/InterfaceStubs/cxx-conversion.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<typename T> class C1 { template<typename T> class C1 {
long a; long a;
operator long() const { return a; } operator long() const { return a; }
}; };

clang/test/InterfaceStubs/cxxdeduction-guide.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs -std=c++17 %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs -std=c++17 %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
// CXXDeductionGuideDecl // CXXDeductionGuideDecl
template<typename T> struct A { A(); A(T); }; template<typename T> struct A { A(); A(T); };
A() -> A<int>; A() -> A<int>;

clang/test/InterfaceStubs/driver-test3.c

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// REQUIRES: shell // REQUIRES: shell
// RUN: mkdir -p %t; cd %t // RUN: mkdir -p %t; cd %t
// RUN: %clang -target x86_64-unknown-linux-gnu -c -emit-interface-stubs %s -o %t/driver-test3.o // RUN: %clang -target x86_64-unknown-linux-gnu -c -emit-interface-stubs %s -o %t/driver-test3.o
// RUN: llvm-nm %t/driver-test3.o | FileCheck --check-prefix=CHECK-OBJ %s // RUN: llvm-nm %t/driver-test3.o | FileCheck --check-prefix=CHECK-OBJ %s
// RUN: cat %t/driver-test3.ifs | FileCheck --check-prefix=CHECK-IFS %s // RUN: cat %t/driver-test3.ifs | FileCheck --check-prefix=CHECK-IFS %s
// CHECK-OBJ: bar // CHECK-OBJ: bar
// CHECK-IFS: --- !experimental-ifs-v1 // CHECK-IFS: --- !experimental-ifs-v2
// CHECK-IFS-NEXT: IfsVersion: // CHECK-IFS-NEXT: IfsVersion:
// CHECK-IFS-NEXT: Triple: // CHECK-IFS-NEXT: Triple:
// CHECK-IFS-NEXT: ObjectFileFormat: // CHECK-IFS-NEXT: ObjectFileFormat:
// CHECK-IFS-NEXT: Symbols: // CHECK-IFS-NEXT: Symbols:
// CHECK-IFS-NEXT: "bar" : { Type: Func } // CHECK-IFS-NEXT: - { Name: "bar", Type: Func }
// CHECK-IFS-NEXT: ... // CHECK-IFS-NEXT: ...
int bar(int a) { return a; } int bar(int a) { return a; }

clang/test/InterfaceStubs/empty.c

  • This file was added.
// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat:
// CHECK-NEXT: Symbols:
// CHECK-NEXT: ...

clang/test/InterfaceStubs/func.ifs

# RUN: %clang -emit-interface-stubs -o - %s %S/object.ifs -emit-merged-ifs | \ # RUN: %clang -emit-interface-stubs -o - %s %S/object.ifs -emit-merged-ifs | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# RUN: %clang -emit-interface-stubs -o - %s %S/object.ifs | llvm-readelf --all | \ # RUN: %clang -emit-interface-stubs -o - %s %S/object.ifs | llvm-readelf --all | \
# RUN: FileCheck %s --check-prefixes=CHECK-ELF # RUN: FileCheck %s --check-prefixes=CHECK-ELF
# RUN: %clang -emit-interface-stubs -o - %s %s -emit-merged-ifs | \ # RUN: %clang -emit-interface-stubs -o - %s %s -emit-merged-ifs | \
# RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS # RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-DAG: a: { Type: Func } # CHECK-IFS-DAG: - { Name: a, Type: Func }
# CHECK-IFS-DAG: b: { Type: Object, Size: 4 } # CHECK-IFS-DAG: - { Name: b, Type: Object, Size: 4 }
# CHECK-IFS: ... # CHECK-IFS: ...
# CHECK-ELF: ELF Header: # CHECK-ELF: ELF Header:
# CHECK-ELF: Class: ELF64 # CHECK-ELF: Class: ELF64
# CHECK-ELF: Type: DYN (Shared object file) # CHECK-ELF: Type: DYN (Shared object file)
# CHECK-ELF: FUNC GLOBAL DEFAULT 1 a # CHECK-ELF: FUNC GLOBAL DEFAULT 1 a
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b
# Here we are testing to see if two identical symbols will merge. # Here we are testing to see if two identical symbols will merge.
# CHECK-MERGE-IFS: --- !experimental-ifs-v1 # CHECK-MERGE-IFS: --- !experimental-ifs-v2
# CHECK-MERGE-IFS-NEXT: IfsVersion: 1.0 # CHECK-MERGE-IFS-NEXT: IfsVersion: 2.0
# CHECK-MERGE-IFS-NEXT: Triple: x86_64-linux-gnu # CHECK-MERGE-IFS-NEXT: Triple: x86_64-linux-gnu
# CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF # CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-MERGE-IFS-NEXT: Symbols: # CHECK-MERGE-IFS-NEXT: Symbols:
# CHECK-MERGE-IFS-NEXT: a: { Type: Func } # CHECK-MERGE-IFS-NEXT: - { Name: a, Type: Func }
# CHECK-MERGE-IFS-NEXT: ... # CHECK-MERGE-IFS-NEXT: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-linux-gnu Triple: x86_64-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Func } - { Name: a, Type: Func }
... ...

clang/test/InterfaceStubs/hidden-class-inheritance.cpp

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \ // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \
// RUN: -DPARENT_CLASS_VISIBILITY="" -DCHILD_CLASS_VISIBILITY="" \ // RUN: -DPARENT_CLASS_VISIBILITY="" -DCHILD_CLASS_VISIBILITY="" \
// RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \ // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
// RUN: FileCheck -check-prefix=CHECK-X %s // RUN: FileCheck -check-prefix=CHECK-X %s
// RUN: %clang -target x86_64-unknown-linux-gnu -o - -c \ // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c \
// RUN: -DPARENT_CLASS_VISIBILITY="" -DCHILD_CLASS_VISIBILITY="" \ // RUN: -DPARENT_CLASS_VISIBILITY="" -DCHILD_CLASS_VISIBILITY="" \
// RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \ // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
// RUN: llvm-readelf -s - 2>&1 | \ // RUN: llvm-readelf -s - 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-X-RE %s // RUN: FileCheck -check-prefix=CHECK-X-RE %s
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \ // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \
// RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \ // RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \
// RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \ // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
// RUN: FileCheck -check-prefix=CHECK-HP %s // RUN: FileCheck -check-prefix=CHECK-HP %s
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \ // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \
// RUN: -interface-stub-version=experimental-ifs-v1 \ // RUN: -interface-stub-version=experimental-ifs-v2 \
// RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \ // RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \
// RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \ // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
// RUN: FileCheck -check-prefix=CHECK-HP2 %s // RUN: FileCheck -check-prefix=CHECK-HP2 %s
// RUN: %clang -target x86_64-unknown-linux-gnu -o - -c \ // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c \
// RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \ // RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \
// RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \ // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
// RUN: llvm-readelf -s - 2>&1 | \ // RUN: llvm-readelf -s - 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-HP-RE %s // RUN: FileCheck -check-prefix=CHECK-HP-RE %s
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

clang/test/InterfaceStubs/indirect-field-decl.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<typename T> class C2 { union { T c; }; }; template<typename T> class C2 { union { T c; }; };

clang/test/InterfaceStubs/inline.c

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
// RUN: %clang_cc1 -DINLINE=inline -triple x86_64-linux-gnu -o - \ // RUN: %clang_cc1 -DINLINE=inline -triple x86_64-linux-gnu -o - \
// RUN: -emit-interface-stubs \ // RUN: -emit-interface-stubs \
// RUN: -std=gnu89 -xc %s | FileCheck -check-prefix=CHECK-SYMBOLS %s // RUN: -std=gnu89 -xc %s | FileCheck -check-prefix=CHECK-SYMBOLS %s
// RUN: %clang -DINLINE=inline -target x86_64-linux-gnu -o - \ // RUN: %clang -DINLINE=inline -target x86_64-linux-gnu -o - \
// RUN: -c -std=gnu89 -xc %s | llvm-nm - 2>&1 | \ // RUN: -c -std=gnu89 -xc %s | llvm-nm - 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s // RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s
// CHECK-TAPI-DAG: foo" : { Type: Func } // CHECK-TAPI-DAG: foo", Type: Func }
// CHECK-TAPI-DAG: foo.var" : { Type: Object, Size: 4 } // CHECK-TAPI-DAG: foo.var", Type: Object, Size: 4 }
// CHECK-SYMBOLS-DAG: foo // CHECK-SYMBOLS-DAG: foo
// CHECK-SYMBOLS-DAG: foo.var // CHECK-SYMBOLS-DAG: foo.var
#include "inline.h" #include "inline.h"

clang/test/InterfaceStubs/lambda.cpp

// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-interface-stubs -o - %s \ // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-interface-stubs -o - %s \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: f" : { Type: Object, Size: 1 } // CHECK-NEXT: f", Type: Object, Size: 1 }
// CHECK-NEXT: ... // CHECK-NEXT: ...
auto f = [](void* data) { int i; }; auto f = [](void* data) { int i; };

clang/test/InterfaceStubs/namespace-alias.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
// NamespaceAliasDecl // NamespaceAliasDecl
namespace NS { } namespace NS { }
namespace B = NS; namespace B = NS;

clang/test/InterfaceStubs/namespace.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
namespace NS1 { } namespace NS1 { }
using namespace NS1; using namespace NS1;

clang/test/InterfaceStubs/non-type-template-parm-decl.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<bool T> struct S1 {}; template<bool T> struct S1 {};

clang/test/InterfaceStubs/object.c

// RUN: %clang_cc1 -fvisibility default -o - -emit-interface-stubs %s | FileCheck -check-prefix=CHECK-TAPI %s // RUN: %clang_cc1 -fvisibility default -o - -emit-interface-stubs %s | FileCheck -check-prefix=CHECK-TAPI %s
// RUN: %clang -fvisibility=default -c -o - %s | llvm-nm - 2>&1 | FileCheck -check-prefix=CHECK-SYMBOLS %s // RUN: %clang -fvisibility=default -c -o - %s | llvm-nm - 2>&1 | FileCheck -check-prefix=CHECK-SYMBOLS %s
// CHECK-TAPI: data" : { Type: Object, Size: 4 } // CHECK-TAPI: data", Type: Object, Size: 4 }
// CHECK-SYMBOLS: data // CHECK-SYMBOLS: data
int data = 42; int data = 42;

clang/test/InterfaceStubs/object.ifs

# RUN: %clang -emit-interface-stubs -o - -emit-merged-ifs %s | \ # RUN: %clang -emit-interface-stubs -o - -emit-merged-ifs %s | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# RUN: %clang -emit-interface-stubs -o - %s | llvm-readelf --all | \ # RUN: %clang -emit-interface-stubs -o - %s | llvm-readelf --all | \
# RUN: FileCheck %s --check-prefixes=CHECK-ELF # RUN: FileCheck %s --check-prefixes=CHECK-ELF
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-NEXT: b: { Type: Object, Size: 4 } # CHECK-IFS-NEXT: - { Name: b, Type: Object, Size: 4 }
# CHECK-IFS-NEXT: ... # CHECK-IFS-NEXT: ...
# CHECK-ELF: ELF Header: # CHECK-ELF: ELF Header:
# CHECK-ELF: Class: ELF64 # CHECK-ELF: Class: ELF64
# CHECK-ELF: Data: 2's complement, little endian # CHECK-ELF: Data: 2's complement, little endian
# CHECK-ELF: Type: DYN (Shared object file) # CHECK-ELF: Type: DYN (Shared object file)
# CHECK-ELF-NOT: FUNC GLOBAL DEFAULT 1 a # CHECK-ELF-NOT: FUNC GLOBAL DEFAULT 1 a
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-linux-gnu Triple: x86_64-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
b: { Type: Object, Size: 4 } - { Name: b, Type: Object, Size: 4 }
... ...

clang/test/InterfaceStubs/ppc.cpp

// REQUIRES: powerpc-registered-target // REQUIRES: powerpc-registered-target
// RUN: %clang -x c++ -target powerpc64le-unknown-linux-gnu -o - %s \ // RUN: %clang -x c++ -target powerpc64le-unknown-linux-gnu -o - %s \
// RUN: -emit-interface-stubs -emit-merged-ifs -S | \ // RUN: -emit-interface-stubs -emit-merged-ifs -S | \
// RUN: FileCheck -check-prefix=CHECK-IFS %s // RUN: FileCheck -check-prefix=CHECK-IFS %s
// CHECK-IFS: --- !experimental-ifs-v1 // CHECK-IFS: --- !experimental-ifs-v2
// CHECK-IFS: IfsVersion: 1.0 // CHECK-IFS: IfsVersion: 2.0
// CHECK-IFS: Triple: powerpc64le // CHECK-IFS: Triple: powerpc64le
// CHECK-IFS: Symbols: // CHECK-IFS: Symbols:
// CHECK-IFS: _Z8helloPPCv: { Type: Func } // CHECK-IFS: - { Name: _Z8helloPPCv, Type: Func }
// CHECK-IFS: ... // CHECK-IFS: ...
int helloPPC(); int helloPPC();

clang/test/InterfaceStubs/template-constexpr.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<typename T, T v> struct S8 { static constexpr T value = v; }; template<typename T, T v> struct S8 { static constexpr T value = v; };
template<typename T, T v> constexpr T S8<T, v>::value; template<typename T, T v> constexpr T S8<T, v>::value;

clang/test/InterfaceStubs/template-namespace-function.cpp

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs %s | \ // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs %s | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: %clang -target x86_64-unknown-linux-gnu -o - -c %s | llvm-nm - 2>&1 | \ // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c %s | llvm-nm - 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s // RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s
// CHECK: Symbols: // CHECK: Symbols:
// CHECK-DAG: "_ZN3qux3barEii" : { Type: Func } // CHECK-DAG: - { Name: "_ZN3qux3barEii", Type: Func }
// CHECK-DAG: "_ZN3baz3addIiEET_S1_S1_" : { Type: Func } // CHECK-DAG: - { Name: "_ZN3baz3addIiEET_S1_S1_", Type: Func }
// CHECK-DAG: "_Z4fbarff" : { Type: Func } // CHECK-DAG: - { Name: "_Z4fbarff", Type: Func }
// CHECK-DAG: "_ZN3baz3addIfEET_S1_S1_" : { Type: Func } // CHECK-DAG: - { Name: "_ZN3baz3addIfEET_S1_S1_", Type: Func }
// Same symbols just different order. // Same symbols just different order.
// CHECK-SYMBOLS-DAG: _Z4fbarff // CHECK-SYMBOLS-DAG: _Z4fbarff
// CHECK-SYMBOLS-DAG: _ZN3baz3addIfEET_S1_S1_ // CHECK-SYMBOLS-DAG: _ZN3baz3addIfEET_S1_S1_
// CHECK-SYMBOLS-DAG: _ZN3baz3addIiEET_S1_S1_ // CHECK-SYMBOLS-DAG: _ZN3baz3addIiEET_S1_S1_
// CHECK-SYMBOLS-DAG: _ZN3qux3barEii // CHECK-SYMBOLS-DAG: _ZN3qux3barEii
namespace baz { namespace baz {
Show All 11 Lines

clang/test/InterfaceStubs/template-template-parm-decl.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<template<typename...> class a> struct S6 { }; template<template<typename...> class a> struct S6 { };

clang/test/InterfaceStubs/trycatch.cpp

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v2
// CHECK: --- !experimental-ifs-v1 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: IfsVersion: 1.0
// CHECK-NEXT: Triple: x86_64-unknown-linux-gnu // CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: "_Z1fv" : { Type: Func } // CHECK-NEXT: - { Name: "_Z1fv", Type: Func }
// CHECK-NEXT: ... // CHECK-NEXT: ...
class C5 {}; class C5 {};
void f() { try {} catch(C5&){} } void f() { try {} catch(C5&){} }

clang/test/InterfaceStubs/unresolved-using-typename.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
// UnresolvedUsingTypenameDecl // UnresolvedUsingTypenameDecl
template<typename T> class C1 { using ReprType = unsigned; }; template<typename T> class C1 { using ReprType = unsigned; };
template<typename T> class C2 : public C1<T> { using typename C1<T>::Repr; }; template<typename T> class C2 : public C1<T> { using typename C1<T>::Repr; };

clang/test/InterfaceStubs/usings.cpp

// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: // CHECK-NEXT: Triple:
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<typename T> struct S2 { static unsigned f(); }; template<typename T> struct S2 { static unsigned f(); };
template<typename T> struct S3 { using S2<T>::f; }; template<typename T> struct S3 { using S2<T>::f; };
typedef struct {} S4; typedef struct {} S4;
using ::S4; using ::S4;
template<typename T, T t> struct C3{}; template<typename T, T t> struct C3{};
template<bool b> using U1 = C3<bool, b>; template<bool b> using U1 = C3<bool, b>;

clang/test/InterfaceStubs/var-template-specialization-decl.cpp

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs %s | FileCheck %s
// CHECK: --- !experimental-ifs-v1 // CHECK: --- !experimental-ifs-v2
// CHECK-NEXT: IfsVersion: 1.0 // CHECK-NEXT: IfsVersion: 2.0
// CHECK-NEXT: Triple: x86_64-unknown-linux-gnu // CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
// CHECK-NEXT: ObjectFileFormat: ELF // CHECK-NEXT: ObjectFileFormat: ELF
// CHECK-NEXT: Symbols: // CHECK-NEXT: Symbols:
// CHECK-NEXT: "a" : { Type: Object, Size: 4 } // CHECK-NEXT: - { Name: "a", Type: Object, Size: 4 }
// CHECK-NEXT: ... // CHECK-NEXT: ...
template<typename T, T v> struct S9 { template<typename T, T v> struct S9 {
static constexpr T value = v; static constexpr T value = v;
}; };
template<typename T> struct S0 : public S9<bool, true> { }; template<typename T> struct S0 : public S9<bool, true> { };
template<typename T> constexpr bool CE2 = S0<T>::value; template<typename T> constexpr bool CE2 = S0<T>::value;
int a = CE2<int>; int a = CE2<int>;

clang/test/InterfaceStubs/weak.cpp

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64-linux-gnu -o - -emit-interface-stubs \ // RUN: %clang_cc1 -triple x86_64-linux-gnu -o - -emit-interface-stubs \
// RUN: -interface-stub-version=experimental-ifs-v1 %s | \ // RUN: -interface-stub-version=experimental-ifs-v2 %s | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: %clang -target x86_64-unknown-linux-gnu -o - -c %s | llvm-nm - 2>&1 | \ // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c %s | llvm-nm - 2>&1 | \
// RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s // RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s
// CHECK: Symbols: // CHECK: Symbols:
// CHECK-DAG: "_Z8weakFuncv" : { Type: Func, Weak: true } // CHECK-DAG: - { Name: "_Z8weakFuncv", Type: Func, Weak: true }
// CHECK-DAG: "_Z10strongFuncv" : { Type: Func } // CHECK-DAG: - { Name: "_Z10strongFuncv", Type: Func }
// CHECK-SYMBOLS-DAG: _Z10strongFuncv // CHECK-SYMBOLS-DAG: _Z10strongFuncv
// CHECK-SYMBOLS-DAG: _Z8weakFuncv // CHECK-SYMBOLS-DAG: _Z8weakFuncv
__attribute__((weak)) void weakFunc() {} __attribute__((weak)) void weakFunc() {}
int strongFunc() { return 42; } int strongFunc() { return 42; }

clang/test/InterfaceStubs/windows.cpp

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -triple x86_64-windows-msvc -o - %s -emit-interface-stubs | FileCheck -check-prefix=CHECK-CC1 %s // RUN: %clang_cc1 -triple x86_64-windows-msvc -o - %s -emit-interface-stubs | FileCheck -check-prefix=CHECK-CC1 %s
// RUN: %clang -target x86_64-windows-msvc -o - %s -emit-interface-stubs -emit-merged-ifs -S | FileCheck -check-prefix=CHECK-IFS %s // RUN: %clang -target x86_64-windows-msvc -o - %s -emit-interface-stubs -emit-merged-ifs -S | FileCheck -check-prefix=CHECK-IFS %s
// note: -S is added here to prevent clang from invoking link.exe // note: -S is added here to prevent clang from invoking link.exe
// CHECK-CC1: Symbols: // CHECK-CC1: Symbols:
// CHECK-CC1-NEXT: ?helloWindowsMsvc@@YAHXZ // CHECK-CC1-NEXT: ?helloWindowsMsvc@@YAHXZ
// CHECK-IFS: --- !experimental-ifs-v1 // CHECK-IFS: --- !experimental-ifs-v2
// CHECK-IFS: IfsVersion: 1.0 // CHECK-IFS: IfsVersion: 2.0
// CHECK-IFS: Triple: // CHECK-IFS: Triple:
// CHECK-IFS: Symbols: // CHECK-IFS: Symbols:
// CHECK-IFS: ?helloWindowsMsvc@@YAHXZ: { Type: Func } // CHECK-IFS: - { Name: '?helloWindowsMsvc@@YAHXZ', Type: Func }
// CHECK-IFS: ... // CHECK-IFS: ...
int helloWindowsMsvc(); int helloWindowsMsvc();

llvm/test/tools/llvm-ifs/Inputs/strong-mismatch-size.ifs

# NOTE: Used by weak-mismatch.ifs # NOTE: Used by weak-mismatch.ifs
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
foobar: { Type: Object, Size: 2 } - { Name: foobar, Type: Object, Size: 2 }
... ...

llvm/test/tools/llvm-ifs/Inputs/strong-mismatch-type.ifs

# NOTE: Used by weak-mismatch.ifs # NOTE: Used by weak-mismatch.ifs
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
foobar: { Type: Func } - { Name: foobar, Type: Func }
... ...

llvm/test/tools/llvm-ifs/conflict-header-format.ifs

# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \ # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# CHECK-IFS: error: Interface Stub: ObjectFileFormat Mismatch. # CHECK-IFS: error: Interface Stub: ObjectFileFormat Mismatch.
# CHECK-IFS-NEXT: Filenames: # CHECK-IFS-NEXT: Filenames:
# CHECK-IFS-NEXT: ObjectFileFormat Values: TBD ELF # CHECK-IFS-NEXT: ObjectFileFormat Values: TBD ELF
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-apple-unknown Triple: x86_64-apple-unknown
ObjectFileFormat: TBD ObjectFileFormat: TBD
Symbols: Symbols:
a: { Type: Func } - { Name: a, Type: Func }
... ...

llvm/test/tools/llvm-ifs/conflict-header-triple.ifs

# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \ # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# CHECK-IFS: error: Interface Stub: Triple Mismatch. # CHECK-IFS: error: Interface Stub: Triple Mismatch.
# CHECK-IFS-NEXT: Filenames: # CHECK-IFS-NEXT: Filenames:
# CHECK-IFS-NEXT: Triple Values: mips-unknown-linux x86_64-unknown-linux-gnu # CHECK-IFS-NEXT: Triple Values: mips-unknown-linux x86_64-unknown-linux-gnu
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: mips-unknown-linux Triple: mips-unknown-linux
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Func } - { Name: a, Type: Func }
... ...

llvm/test/tools/llvm-ifs/conflict-header-version.ifs

# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \ # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# RUN: not llvm-ifs -action write-ifs -o - %s 2>&1 | \ # RUN: not llvm-ifs -action write-ifs -o - %s 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS2 # RUN: FileCheck %s --check-prefixes=CHECK-IFS2
# CHECK-IFS: error: Interface Stub: IfsVersion Mismatch. # CHECK-IFS: error: Interface Stub: IfsVersion Mismatch.
# CHECK-IFS2: error: Interface Stub: Bad IfsVersion: 0.0, llvm-ifs supported version: 1.2. # CHECK-IFS2: error: Interface Stub: Bad IfsVersion: 0.0, llvm-ifs supported version: 2.0.
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 0.0 IfsVersion: 0.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Func } - { Name: a, Type: Func }
... ...

llvm/test/tools/llvm-ifs/conflict-size.ifs

# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \ # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# Here we are testing to see if two symbols with identical names will fail to # Here we are testing to see if two symbols with identical names will fail to
# merge in conflict due to mismatching sizes. # merge in conflict due to mismatching sizes.
# CHECK-IFS: error: Interface Stub: Size Mismatch for b. # CHECK-IFS: error: Interface Stub: Size Mismatch for b.
# CHECK-IFS-NEXT: Filename: # CHECK-IFS-NEXT: Filename:
# CHECK-IFS-NEXT: Size Values: 1 4 # CHECK-IFS-NEXT: Size Values: 1 4
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
b: { Type: Object, Size: 1 } - { Name: b, Type: Object, Size: 1 }
... ...

llvm/test/tools/llvm-ifs/conflict-type.ifs

# RUN: not llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \ # RUN: not llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# Here we are testing to see if two symbols with identical names will fail to # Here we are testing to see if two symbols with identical names will fail to
# merge in conflict due to mismatched types. # merge in conflict due to mismatched types.
# CHECK-IFS: error: Interface Stub: Type Mismatch for a. # CHECK-IFS: error: Interface Stub: Type Mismatch for a.
# CHECK-IFS-NEXT: Filename: # CHECK-IFS-NEXT: Filename:
# CHECK-IFS-NEXT: Type Values: Object Func # CHECK-IFS-NEXT: Type Values: Object Func
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Object, Size: 1 } - { Name: a, Type: Object, Size: 1 }
... ...

llvm/test/tools/llvm-ifs/conflict-weak.ifs

# RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \ # RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# CHECK-IFS: Symbols: # CHECK-IFS: Symbols:
# CHECK-IFS-NEXT: a: { Type: Func, Weak: true } # CHECK-IFS-NEXT: - { Name: a, Type: Func, Weak: true }
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Func, Weak: true } - { Name: a, Type: Func, Weak: true }
... ...

llvm/test/tools/llvm-ifs/default-empty.ifs

# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck --check-prefixes=CHECK-DEFAULT %s # RUN: llvm-ifs -action write-ifs -o - %s | FileCheck --check-prefixes=CHECK-DEFAULT %s
# RUN: llvm-ifs -action write-ifs -o - %s %S/weak.ifs | FileCheck --check-prefixes=CHECK-MERGE %s # RUN: llvm-ifs -action write-ifs -o - %s %S/weak.ifs | FileCheck --check-prefixes=CHECK-MERGE %s
# CHECK-DEFAULT: --- !experimental-ifs-v1 # CHECK-DEFAULT: --- !experimental-ifs-v2
# CHECK-DEFAULT-NEXT: IfsVersion: 1.2 # CHECK-DEFAULT-NEXT: IfsVersion: 2.0
# CHECK-DEFAULT-NEXT: Triple: '' # CHECK-DEFAULT-NEXT: Triple: ''
# CHECK-DEFAULT-NEXT: ObjectFileFormat: ELF # CHECK-DEFAULT-NEXT: ObjectFileFormat: ELF
# CHECK-DEFAULT-NEXT: Symbols: {} # CHECK-DEFAULT-NEXT: Symbols: []
# CHECK-DEFAULT-NEXT: ... # CHECK-DEFAULT-NEXT: ...
# CHECK-MERGE: --- !experimental-ifs-v1 # CHECK-MERGE: --- !experimental-ifs-v2
# CHECK-MERGE-NEXT: IfsVersion: 1.0 # CHECK-MERGE-NEXT: IfsVersion: 2.0
# CHECK-MERGE-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-MERGE-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-MERGE-NEXT: ObjectFileFormat: ELF # CHECK-MERGE-NEXT: ObjectFileFormat: ELF
# CHECK-MERGE-NEXT: Symbols: # CHECK-MERGE-NEXT: Symbols:
# CHECK-MERGE-DAG: _Z8weakFuncv: { Type: Func, Weak: true } # CHECK-MERGE-DAG: - { Name: _Z8weakFuncv, Type: Func, Weak: true }
# CHECK-MERGE-DAG: _Z10strongFuncv: { Type: Func } # CHECK-MERGE-DAG: - { Name: _Z10strongFuncv, Type: Func }
# CHECK-MERGE: ... # CHECK-MERGE: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.2 IfsVersion: 2.0
Triple: '' Triple: ''
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: {} Symbols: []
... ...

llvm/test/tools/llvm-ifs/empty1.ifs

  • This file was added.
# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s
# CHECK: --- !experimental-ifs-v2
# CHECK-NEXT: IfsVersion: 2.0
# CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-NEXT: ObjectFileFormat: ELF
# CHECK-NEXT: Symbols: []
# CHECK: ...
--- !experimental-ifs-v2
IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF
Symbols: []
...

llvm/test/tools/llvm-ifs/empty2.ifs

  • This file was added.
# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s
# CHECK: --- !experimental-ifs-v2
# CHECK-NEXT: IfsVersion: 2.0
# CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-NEXT: ObjectFileFormat: ELF
# CHECK-NEXT: Symbols: []
# CHECK: ...
--- !experimental-ifs-v2
IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF
Symbols:
...

llvm/test/tools/llvm-ifs/func.ifs

# RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs | \ # RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# RUN: llvm-ifs -action write-bin -o - %s %S/object.ifs | \ # RUN: llvm-ifs -action write-bin -o - %s %S/object.ifs | \
# RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF # RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF
# RUN: llvm-ifs -action write-bin -force-format TBD -o - %s %S/object.ifs | \ # RUN: llvm-ifs -action write-bin -force-format TBD -o - %s %S/object.ifs | \
# RUN: FileCheck %s --check-prefixes=CHECK-DARWIN-TBD3 # RUN: FileCheck %s --check-prefixes=CHECK-DARWIN-TBD3
# RUN: llvm-ifs -action write-ifs -o - %s %s | \ # RUN: llvm-ifs -action write-ifs -o - %s %s | \
# RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS # RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-DAG: a: { Type: Func } # CHECK-IFS-DAG: - { Name: a, Type: Func }
# CHECK-IFS-DAG: b: { Type: Object, Size: 4 } # CHECK-IFS-DAG: - { Name: b, Type: Object, Size: 4 }
# CHECK-IFS: ... # CHECK-IFS: ...
# CHECK-ELF: ELF Header: # CHECK-ELF: ELF Header:
# CHECK-ELF: Class: ELF64 # CHECK-ELF: Class: ELF64
# CHECK-ELF: Type: DYN (Shared object file) # CHECK-ELF: Type: DYN (Shared object file)
# CHECK-ELF: FUNC GLOBAL DEFAULT 1 a # CHECK-ELF: FUNC GLOBAL DEFAULT 1 a
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b
# CHECK-DARWIN-TBD3: --- !tapi-tbd-v3 # CHECK-DARWIN-TBD3: --- !tapi-tbd-v3
# CHECK-DARWIN-TBD3-NEXT: archs: [ x86_64 ] # CHECK-DARWIN-TBD3-NEXT: archs: [ x86_64 ]
# CHECK-DARWIN-TBD3-NEXT: platform: macosx # CHECK-DARWIN-TBD3-NEXT: platform: macosx
# CHECK-DARWIN-TBD3-NEXT: flags: [ flat_namespace, not_app_extension_safe ] # CHECK-DARWIN-TBD3-NEXT: flags: [ flat_namespace, not_app_extension_safe ]
# CHECK-DARWIN-TBD3-NEXT: install-name: '' # CHECK-DARWIN-TBD3-NEXT: install-name: ''
# CHECK-DARWIN-TBD3-NEXT: current-version: 0 # CHECK-DARWIN-TBD3-NEXT: current-version: 0
# CHECK-DARWIN-TBD3-NEXT: compatibility-version: 0 # CHECK-DARWIN-TBD3-NEXT: compatibility-version: 0
# CHECK-DARWIN-TBD3-NEXT: objc-constraint: none # CHECK-DARWIN-TBD3-NEXT: objc-constraint: none
# CHECK-DARWIN-TBD3-NEXT: exports: # CHECK-DARWIN-TBD3-NEXT: exports:
# CHECK-DARWIN-TBD3-NEXT: - archs: [ x86_64 ] # CHECK-DARWIN-TBD3-NEXT: - archs: [ x86_64 ]
# CHECK-DARWIN-TBD3-NEXT: symbols: [ a, b ] # CHECK-DARWIN-TBD3-NEXT: symbols: [ a, b ]
# CHECK-DARWIN-TBD3-NEXT: ... # CHECK-DARWIN-TBD3-NEXT: ...
# Here we are testing to see if two identical symbols will merge. # Here we are testing to see if two identical symbols will merge.
# CHECK-MERGE-IFS: --- !experimental-ifs-v1 # CHECK-MERGE-IFS: --- !experimental-ifs-v2
# CHECK-MERGE-IFS-NEXT: IfsVersion: 1.0 # CHECK-MERGE-IFS-NEXT: IfsVersion: 2.0
# CHECK-MERGE-IFS-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-MERGE-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF # CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-MERGE-IFS-NEXT: Symbols: # CHECK-MERGE-IFS-NEXT: Symbols:
# CHECK-MERGE-IFS-NEXT: a: { Type: Func } # CHECK-MERGE-IFS-NEXT: - { Name: a, Type: Func }
# CHECK-MERGE-IFS-NEXT: ... # CHECK-MERGE-IFS-NEXT: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Func } - { Name: a, Type: Func }
... ...

llvm/test/tools/llvm-ifs/ios-tbd.ifs

# RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
# CHECK: --- !tapi-tbd-v3 # CHECK: --- !tapi-tbd-v3
# CHECK-NEXT: archs: [ arm64 ] # CHECK-NEXT: archs: [ arm64 ]
# CHECK-NEXT: platform: ios # CHECK-NEXT: platform: ios
# CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ] # CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ]
# CHECK-NEXT: install-name: '' # CHECK-NEXT: install-name: ''
# CHECK-NEXT: current-version: 0 # CHECK-NEXT: current-version: 0
# CHECK-NEXT: compatibility-version: 0 # CHECK-NEXT: compatibility-version: 0
# CHECK-NEXT: objc-constraint: none # CHECK-NEXT: objc-constraint: none
# CHECK-NEXT: exports: # CHECK-NEXT: exports:
# CHECK-NEXT: - archs: [ arm64 ] # CHECK-NEXT: - archs: [ arm64 ]
# CHECK-NEXT: symbols: [ __Z3fooi ] # CHECK-NEXT: symbols: [ __Z3fooi ]
# CHECK-NEXT: ... # CHECK-NEXT: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: arm64-apple-ios Triple: arm64-apple-ios
ObjectFileFormat: TBD ObjectFileFormat: TBD
Symbols: Symbols:
__Z3fooi: { Type: Func } - { Name: __Z3fooi, Type: Func }
... ...

llvm/test/tools/llvm-ifs/macos-tbd.ifs

# RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
# CHECK: --- !tapi-tbd-v3 # CHECK: --- !tapi-tbd-v3
# CHECK-NEXT: archs: [ arm64 ] # CHECK-NEXT: archs: [ arm64 ]
# CHECK-NEXT: platform: macosx # CHECK-NEXT: platform: macosx
# CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ] # CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ]
# CHECK-NEXT: install-name: '' # CHECK-NEXT: install-name: ''
# CHECK-NEXT: current-version: 0 # CHECK-NEXT: current-version: 0
# CHECK-NEXT: compatibility-version: 0 # CHECK-NEXT: compatibility-version: 0
# CHECK-NEXT: objc-constraint: none # CHECK-NEXT: objc-constraint: none
# CHECK-NEXT: exports: # CHECK-NEXT: exports:
# CHECK-NEXT: - archs: [ arm64 ] # CHECK-NEXT: - archs: [ arm64 ]
# CHECK-NEXT: symbols: [ __Z3fooi ] # CHECK-NEXT: symbols: [ __Z3fooi ]
# CHECK-NEXT: ... # CHECK-NEXT: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: arm64-apple-macosx Triple: arm64-apple-macosx
ObjectFileFormat: TBD ObjectFileFormat: TBD
Symbols: Symbols:
__Z3fooi: { Type: Func } - { Name: __Z3fooi, Type: Func }
... ...

llvm/test/tools/llvm-ifs/object-function-size-weak-combo.ifs

# RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \ # RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# RUN: llvm-ifs -action write-bin -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \ # RUN: llvm-ifs -action write-bin -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
# RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF # RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-DAG: e: { Type: Object, Size: 8 } # CHECK-IFS-DAG: - { Name: e, Type: Object, Size: 8 }
# CHECK-IFS-DAG: a: { Type: Func } # CHECK-IFS-DAG: - { Name: a, Type: Func }
# CHECK-IFS-DAG: f: { Type: Object, Size: 2 } # CHECK-IFS-DAG: - { Name: f, Type: Object, Size: 2 }
# CHECK-IFS-DAG: _Z10strongFuncv: { Type: Func } # CHECK-IFS-DAG: - { Name: _Z10strongFuncv, Type: Func }
# CHECK-IFS-DAG: _Z8weakFuncv: { Type: Func, Weak: true } # CHECK-IFS-DAG: - { Name: _Z8weakFuncv, Type: Func, Weak: true }
# CHECK-IFS-DAG: b: { Type: Object, Size: 4 } # CHECK-IFS-DAG: - { Name: b, Type: Object, Size: 4 }
# CHECK-IFS: ... # CHECK-IFS: ...
# CHECK-ELF: FUNC GLOBAL DEFAULT 1 _Z10strongFuncv # CHECK-ELF: FUNC GLOBAL DEFAULT 1 _Z10strongFuncv
# CHECK-ELF: FUNC WEAK DEFAULT 1 _Z8weakFuncv # CHECK-ELF: FUNC WEAK DEFAULT 1 _Z8weakFuncv
# CHECK-ELF: FUNC GLOBAL DEFAULT 1 a # CHECK-ELF: FUNC GLOBAL DEFAULT 1 a
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 e # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 e
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 f # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 f
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
e: { Type: Object, Size: 8 } - { Name: e, Type: Object, Size: 8 }
f: { Type: Object, Size: 2 } - { Name: f, Type: Object, Size: 2 }
... ...

llvm/test/tools/llvm-ifs/object.ifs

# RUN: llvm-ifs -action write-ifs -o - %s | \ # RUN: llvm-ifs -action write-ifs -o - %s | \
# RUN: FileCheck %s --check-prefixes=CHECK-IFS # RUN: FileCheck %s --check-prefixes=CHECK-IFS
# RUN: llvm-ifs -action write-bin -o - %s | \ # RUN: llvm-ifs -action write-bin -o - %s | \
# RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF # RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-NEXT: b: { Type: Object, Size: 4 } # CHECK-IFS-NEXT: - { Name: b, Type: Object, Size: 4 }
# CHECK-IFS-NEXT: ... # CHECK-IFS-NEXT: ...
# CHECK-ELF: ELF Header: # CHECK-ELF: ELF Header:
# CHECK-ELF: Class: ELF64 # CHECK-ELF: Class: ELF64
# CHECK-ELF: Data: 2's complement, little endian # CHECK-ELF: Data: 2's complement, little endian
# CHECK-ELF: Type: DYN (Shared object file) # CHECK-ELF: Type: DYN (Shared object file)
# CHECK-ELF-NOT: FUNC GLOBAL DEFAULT 1 a # CHECK-ELF-NOT: FUNC GLOBAL DEFAULT 1 a
# CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b # CHECK-ELF: OBJECT GLOBAL DEFAULT 1 b
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
b: { Type: Object, Size: 4 } - { Name: b, Type: Object, Size: 4 }
... ...

llvm/test/tools/llvm-ifs/strong.ifs

# RUN: llvm-ifs -action write-ifs -o - %s %S/strong.ifs | FileCheck %s --check-prefixes=CHECK-IFS # RUN: llvm-ifs -action write-ifs -o - %s %S/strong.ifs | FileCheck %s --check-prefixes=CHECK-IFS
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-DAG: _Z8weakFuncv: { Type: Func } # CHECK-IFS-DAG: - { Name: _Z8weakFuncv, Type: Func }
# CHECK-IFS: ... # CHECK-IFS: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
_Z8weakFuncv: { Type: Func } - { Name: _Z8weakFuncv, Type: Func }
... ...

llvm/test/tools/llvm-ifs/tvos-tbd.ifs

# RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
# CHECK: --- !tapi-tbd-v3 # CHECK: --- !tapi-tbd-v3
# CHECK-NEXT: archs: [ arm64 ] # CHECK-NEXT: archs: [ arm64 ]
# CHECK-NEXT: platform: tvos # CHECK-NEXT: platform: tvos
# CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ] # CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ]
# CHECK-NEXT: install-name: '' # CHECK-NEXT: install-name: ''
# CHECK-NEXT: current-version: 0 # CHECK-NEXT: current-version: 0
# CHECK-NEXT: compatibility-version: 0 # CHECK-NEXT: compatibility-version: 0
# CHECK-NEXT: objc-constraint: none # CHECK-NEXT: objc-constraint: none
# CHECK-NEXT: exports: # CHECK-NEXT: exports:
# CHECK-NEXT: - archs: [ arm64 ] # CHECK-NEXT: - archs: [ arm64 ]
# CHECK-NEXT: symbols: [ __Z3fooi ] # CHECK-NEXT: symbols: [ __Z3fooi ]
# CHECK-NEXT: ... # CHECK-NEXT: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: arm64-apple-tvos Triple: arm64-apple-tvos
ObjectFileFormat: TBD ObjectFileFormat: TBD
Symbols: Symbols:
__Z3fooi: { Type: Func } - { Name: __Z3fooi, Type: Func }
... ...

llvm/test/tools/llvm-ifs/version-ok.ifs

# RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs # RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.1 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
a: { Type: Func } - { Name: a, Type: Func }
... ...

llvm/test/tools/llvm-ifs/watchos-tbd.ifs

# RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
# CHECK: --- !tapi-tbd-v3 # CHECK: --- !tapi-tbd-v3
# CHECK-NEXT: archs: [ arm64 ] # CHECK-NEXT: archs: [ arm64 ]
# CHECK-NEXT: platform: watchos # CHECK-NEXT: platform: watchos
# CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ] # CHECK-NEXT: flags: [ flat_namespace, not_app_extension_safe ]
# CHECK-NEXT: install-name: '' # CHECK-NEXT: install-name: ''
# CHECK-NEXT: current-version: 0 # CHECK-NEXT: current-version: 0
# CHECK-NEXT: compatibility-version: 0 # CHECK-NEXT: compatibility-version: 0
# CHECK-NEXT: objc-constraint: none # CHECK-NEXT: objc-constraint: none
# CHECK-NEXT: exports: # CHECK-NEXT: exports:
# CHECK-NEXT: - archs: [ arm64 ] # CHECK-NEXT: - archs: [ arm64 ]
# CHECK-NEXT: symbols: [ __Z3fooi ] # CHECK-NEXT: symbols: [ __Z3fooi ]
# CHECK-NEXT: ... # CHECK-NEXT: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: arm64-apple-watchos Triple: arm64-apple-watchos
ObjectFileFormat: TBD ObjectFileFormat: TBD
Symbols: Symbols:
__Z3fooi: { Type: Func } - { Name: __Z3fooi, Type: Func }
... ...

llvm/test/tools/llvm-ifs/weak-mismatch.ifs

# RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-size.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-SIZE # RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-size.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-SIZE
# RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-type.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-TYPE # RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-type.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-TYPE
# CHECK-SIZE: error: Interface Stub: Size Mismatch for foobar. # CHECK-SIZE: error: Interface Stub: Size Mismatch for foobar.
# CHECK-SIZE-NEXT: Filename: # CHECK-SIZE-NEXT: Filename:
# CHECK-SIZE-NEXT: Size Values: 1 2 # CHECK-SIZE-NEXT: Size Values: 1 2
# CHECK-TYPE: error: Interface Stub: Type Mismatch for foobar. # CHECK-TYPE: error: Interface Stub: Type Mismatch for foobar.
# CHECK-TYPE-NEXT: Filename: # CHECK-TYPE-NEXT: Filename:
# CHECK-TYPE-NEXT: Type Values: Object Func # CHECK-TYPE-NEXT: Type Values: Object Func
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
foobar: { Type: Object, Size: 1, Weak: true } - { Name: foobar, Type: Object, Size: 1, Weak: true }
... ...

llvm/test/tools/llvm-ifs/weak.ifs

# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s --check-prefixes=CHECK-IFS # RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s --check-prefixes=CHECK-IFS
# CHECK-IFS: --- !experimental-ifs-v1 # CHECK-IFS: --- !experimental-ifs-v2
# CHECK-IFS-NEXT: IfsVersion: 1.0 # CHECK-IFS-NEXT: IfsVersion: 2.0
# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
# CHECK-IFS-NEXT: ObjectFileFormat: ELF # CHECK-IFS-NEXT: ObjectFileFormat: ELF
# CHECK-IFS-NEXT: Symbols: # CHECK-IFS-NEXT: Symbols:
# CHECK-IFS-DAG: _Z8weakFuncv: { Type: Func, Weak: true } # CHECK-IFS-DAG: - { Name: _Z8weakFuncv, Type: Func, Weak: true }
# CHECK-IFS-DAG: _Z10strongFuncv: { Type: Func } # CHECK-IFS-DAG: - { Name: _Z10strongFuncv, Type: Func }
# CHECK-IFS: ... # CHECK-IFS: ...
--- !experimental-ifs-v1 --- !experimental-ifs-v2
IfsVersion: 1.0 IfsVersion: 2.0
Triple: x86_64-unknown-linux-gnu Triple: x86_64-unknown-linux-gnu
ObjectFileFormat: ELF ObjectFileFormat: ELF
Symbols: Symbols:
_Z8weakFuncv: { Type: Func, Weak: true } - { Name: _Z8weakFuncv, Type: Func, Weak: true }
_Z10strongFuncv: { Type: Func } - { Name: _Z10strongFuncv, Type: Func }
... ...

llvm/tools/llvm-ifs/llvm-ifs.cpp

Show All 20 Lines
#include "llvm/Support/WithColor.h" #include "llvm/Support/WithColor.h"
#include "llvm/Support/YAMLTraits.h" #include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/TextAPI/MachO/InterfaceFile.h" #include "llvm/TextAPI/MachO/InterfaceFile.h"
#include "llvm/TextAPI/MachO/TextAPIReader.h" #include "llvm/TextAPI/MachO/TextAPIReader.h"
#include "llvm/TextAPI/MachO/TextAPIWriter.h" #include "llvm/TextAPI/MachO/TextAPIWriter.h"
#include <set> #include <set>
#include <string> #include <string>
#include <vector>
using namespace llvm; using namespace llvm;
using namespace llvm::yaml; using namespace llvm::yaml;
using namespace llvm::MachO; using namespace llvm::MachO;
#define DEBUG_TYPE "llvm-ifs" #define DEBUG_TYPE "llvm-ifs"
namespace { namespace {
const VersionTuple IFSVersionCurrent(1, 2); const VersionTuple IFSVersionCurrent(2, 0);
} } // end anonymous namespace
static cl::opt<std::string> Action("action", cl::desc("<llvm-ifs action>"), static cl::opt<std::string> Action("action", cl::desc("<llvm-ifs action>"),
cl::value_desc("write-ifs | write-bin"), cl::value_desc("write-ifs | write-bin"),
cl::init("write-ifs")); cl::init("write-ifs"));
static cl::opt<std::string> ForceFormat("force-format", static cl::opt<std::string> ForceFormat("force-format",
cl::desc("<force object format>"), cl::desc("<force object format>"),
cl::value_desc("ELF | TBD"), cl::value_desc("ELF | TBD"),
Show All 24 Lines case IFSSymbolType::Object:
return "Object"; return "Object";
case IFSSymbolType::Unknown: case IFSSymbolType::Unknown:
return "Unknown"; return "Unknown";
} }
llvm_unreachable("Unexpected ifs symbol type."); llvm_unreachable("Unexpected ifs symbol type.");
} }
struct IFSSymbol { struct IFSSymbol {
IFSSymbol() = default;
IFSSymbol(std::string SymbolName) : Name(SymbolName) {} IFSSymbol(std::string SymbolName) : Name(SymbolName) {}
std::string Name; std::string Name;
uint64_t Size; uint64_t Size;
IFSSymbolType Type; IFSSymbolType Type;
bool Weak; bool Weak;
Optional<std::string> Warning; Optional<std::string> Warning;
bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; } bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
}; };
LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
namespace llvm { namespace llvm {
namespace yaml { namespace yaml {
/// YAML traits for IFSSymbolType. /// YAML traits for IFSSymbolType.
template <> struct ScalarEnumerationTraits<IFSSymbolType> { template <> struct ScalarEnumerationTraits<IFSSymbolType> {
static void enumeration(IO &IO, IFSSymbolType &SymbolType) { static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType); IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType);
IO.enumCase(SymbolType, "Func", IFSSymbolType::Func); IO.enumCase(SymbolType, "Func", IFSSymbolType::Func);
IO.enumCase(SymbolType, "Object", IFSSymbolType::Object); IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
Show All 23 Linestemplate <> struct ScalarTraits<VersionTuple> {
// Don't place quotation marks around version value. // Don't place quotation marks around version value.
static QuotingType mustQuote(StringRef) { return QuotingType::None; } static QuotingType mustQuote(StringRef) { return QuotingType::None; }
}; };
/// YAML traits for IFSSymbol. /// YAML traits for IFSSymbol.
template <> struct MappingTraits<IFSSymbol> { template <> struct MappingTraits<IFSSymbol> {
static void mapping(IO &IO, IFSSymbol &Symbol) { static void mapping(IO &IO, IFSSymbol &Symbol) {
IO.mapRequired("Name", Symbol.Name);
IO.mapRequired("Type", Symbol.Type); IO.mapRequired("Type", Symbol.Type);
// The need for symbol size depends on the symbol type. // The need for symbol size depends on the symbol type.
if (Symbol.Type == IFSSymbolType::NoType) if (Symbol.Type == IFSSymbolType::NoType)
IO.mapOptional("Size", Symbol.Size, (uint64_t)0); IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
else if (Symbol.Type == IFSSymbolType::Func) else if (Symbol.Type == IFSSymbolType::Func)
Symbol.Size = 0; Symbol.Size = 0;
else else
IO.mapRequired("Size", Symbol.Size); IO.mapRequired("Size", Symbol.Size);
IO.mapOptional("Weak", Symbol.Weak, false); IO.mapOptional("Weak", Symbol.Weak, false);
IO.mapOptional("Warning", Symbol.Warning); IO.mapOptional("Warning", Symbol.Warning);
} }
// Compacts symbol information into a single line. // Compacts symbol information into a single line.
static const bool flow = true; static const bool flow = true;
}; };
/// YAML traits for set of IFSSymbols.
template <> struct CustomMappingTraits<std::set<IFSSymbol>> {
static void inputOne(IO &IO, StringRef Key, std::set<IFSSymbol> &Set) {
std::string Name = Key.str();
IFSSymbol Sym(Name);
IO.mapRequired(Name.c_str(), Sym);
Set.insert(Sym);
}
static void output(IO &IO, std::set<IFSSymbol> &Set) {
for (auto &Sym : Set)
IO.mapRequired(Sym.Name.c_str(), const_cast<IFSSymbol &>(Sym));
}
};
} // namespace yaml } // namespace yaml
} // namespace llvm } // namespace llvm
// A cumulative representation of ELF stubs. // A cumulative representation of ELF stubs.
// Both textual and binary stubs will read into and write from this object. // Both textual and binary stubs will read into and write from this object.
class IFSStub { class IFSStub {
// TODO: Add support for symbol versioning. // TODO: Add support for symbol versioning.
public: public:
VersionTuple IfsVersion; VersionTuple IfsVersion;
std::string Triple; std::string Triple;
std::string ObjectFileFormat; std::string ObjectFileFormat;
Optional<std::string> SOName; Optional<std::string> SOName;
std::vector<std::string> NeededLibs; std::vector<std::string> NeededLibs;
std::set<IFSSymbol> Symbols; std::vector<IFSSymbol> Symbols;
IFSStub() = default; IFSStub() = default;
IFSStub(const IFSStub &Stub) IFSStub(const IFSStub &Stub)
: IfsVersion(Stub.IfsVersion), Triple(Stub.Triple), : IfsVersion(Stub.IfsVersion), Triple(Stub.Triple),
ObjectFileFormat(Stub.ObjectFileFormat), SOName(Stub.SOName), ObjectFileFormat(Stub.ObjectFileFormat), SOName(Stub.SOName),
NeededLibs(Stub.NeededLibs), Symbols(Stub.Symbols) {} NeededLibs(Stub.NeededLibs), Symbols(Stub.Symbols) {}
IFSStub(IFSStub &&Stub) IFSStub(IFSStub &&Stub)
: IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)), : IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)),
ObjectFileFormat(std::move(Stub.ObjectFileFormat)), ObjectFileFormat(std::move(Stub.ObjectFileFormat)),
SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)), SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)),
Symbols(std::move(Stub.Symbols)) {} Symbols(std::move(Stub.Symbols)) {}
}; };
namespace llvm { namespace llvm {
namespace yaml { namespace yaml {
/// YAML traits for IFSStub objects. /// YAML traits for IFSStub objects.
template <> struct MappingTraits<IFSStub> { template <> struct MappingTraits<IFSStub> {
static void mapping(IO &IO, IFSStub &Stub) { static void mapping(IO &IO, IFSStub &Stub) {
if (!IO.mapTag("!experimental-ifs-v1", true)) if (!IO.mapTag("!experimental-ifs-v2", true))
IO.setError("Not a .ifs YAML file."); IO.setError("Not a .ifs YAML file.");
auto OldContext = IO.getContext();
IO.setContext(&Stub);
IO.mapRequired("IfsVersion", Stub.IfsVersion); IO.mapRequired("IfsVersion", Stub.IfsVersion);
IO.mapOptional("Triple", Stub.Triple); IO.mapOptional("Triple", Stub.Triple);
IO.mapOptional("ObjectFileFormat", Stub.ObjectFileFormat); IO.mapOptional("ObjectFileFormat", Stub.ObjectFileFormat);
IO.mapOptional("SOName", Stub.SOName); IO.mapOptional("SOName", Stub.SOName);
IO.mapOptional("NeededLibs", Stub.NeededLibs); IO.mapOptional("NeededLibs", Stub.NeededLibs);
IO.mapRequired("Symbols", Stub.Symbols); IO.mapRequired("Symbols", Stub.Symbols);
IO.setContext(&OldContext);
} }
}; };
} // namespace yaml } // namespace yaml
} // namespace llvm } // namespace llvm
static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) { static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
// Read in file. // Read in file.
ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError = ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
MemoryBuffer::getFileOrSTDIN(FilePath); MemoryBuffer::getFileOrSTDIN(FilePath);
if (!BufOrError) if (!BufOrError)
return createStringError(BufOrError.getError(), "Could not open `%s`", return createStringError(BufOrError.getError(), "Could not open `%s`",
FilePath.data()); FilePath.data());
std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError); std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
yaml::Input YamlIn(FileReadBuffer->getBuffer()); yaml::Input YamlIn(FileReadBuffer->getBuffer());
std::unique_ptr<IFSStub> Stub(new IFSStub()); std::unique_ptr<IFSStub> Stub(new IFSStub());
YamlIn >> *Stub; YamlIn >> *Stub;
if (std::error_code Err = YamlIn.error()) if (std::error_code Err = YamlIn.error())
return createStringError(Err, "Failed reading Interface Stub File."); return createStringError(Err, "Failed reading Interface Stub File.");
return std::move(Stub); return std::move(Stub);
} }
int writeTbdStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols, int writeTbdStub(const llvm::Triple &T, const std::vector<IFSSymbol> &Symbols,
const StringRef Format, raw_ostream &Out) { const StringRef Format, raw_ostream &Out) {
auto PlatformKindOrError = auto PlatformKindOrError =
[](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> { [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> {
if (T.isMacOSX()) if (T.isMacOSX())
return llvm::MachO::PlatformKind::macOS; return llvm::MachO::PlatformKind::macOS;
if (T.isTvOS()) if (T.isTvOS())
return llvm::MachO::PlatformKind::tvOS; return llvm::MachO::PlatformKind::tvOS;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint writeTbdStub(const llvm::Triple &T, const std::vector<IFSSymbol> &Symbols,
SmallString<4096> Buffer; SmallString<4096> Buffer;
raw_svector_ostream OS(Buffer); raw_svector_ostream OS(Buffer);
if (Error Result = TextAPIWriter::writeToStream(OS, File)) if (Error Result = TextAPIWriter::writeToStream(OS, File))
return -1; return -1;
Out << OS.str(); Out << OS.str();
return 0; return 0;
} }
int writeElfStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols, int writeElfStub(const llvm::Triple &T, const std::vector<IFSSymbol> &Symbols,
const StringRef Format, raw_ostream &Out) { const StringRef Format, raw_ostream &Out) {
SmallString<0> Storage; SmallString<0> Storage;
Storage.clear(); Storage.clear();
raw_svector_ostream OS(Storage); raw_svector_ostream OS(Storage);
OS << "--- !ELF\n"; OS << "--- !ELF\n";
OS << "FileHeader:\n"; OS << "FileHeader:\n";
OS << " Class: ELFCLASS"; OS << " Class: ELFCLASS";
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Linesint writeIfso(const IFSStub &Stub, bool IsWriteIfs, raw_ostream &Out) {
WithColor::error() WithColor::error()
<< "Invalid ObjectFileFormat: Only ELF and TBD are supported.\n"; << "Invalid ObjectFileFormat: Only ELF and TBD are supported.\n";
return -1; return -1;
} }
// TODO: Drop ObjectFileFormat, it can be subsumed from the triple. // TODO: Drop ObjectFileFormat, it can be subsumed from the triple.
// New Interface Stubs Yaml Format: // New Interface Stubs Yaml Format:
// --- !experimental-ifs-v1 // --- !experimental-ifs-v2
// IfsVersion: 1.0 // IfsVersion: 2.0
// Triple: <llvm triple> // Triple: <llvm triple>
// ObjectFileFormat: <ELF | others not yet supported> // ObjectFileFormat: <ELF | others not yet supported>
// Symbols: // Symbols:
// _ZSymbolName: { Type: <type> } // _ZSymbolName: { Type: <type> }
// ... // ...
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
// Parse arguments. // Parse arguments.
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines if (Stub.IfsVersion != IFSVersionCurrent)
if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) { if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) {
WithColor::error() << "Interface Stub: Bad IfsVersion: " WithColor::error() << "Interface Stub: Bad IfsVersion: "
<< Stub.IfsVersion << ", llvm-ifs supported version: " << Stub.IfsVersion << ", llvm-ifs supported version: "
<< IFSVersionCurrent << ".\n"; << IFSVersionCurrent << ".\n";
return -1; return -1;
} }
for (auto &Entry : SymbolMap) for (auto &Entry : SymbolMap)
Stub.Symbols.insert(Entry.second); Stub.Symbols.push_back(Entry.second);
std::error_code SysErr; std::error_code SysErr;
// Open file for writing. // Open file for writing.
raw_fd_ostream Out(OutputFilename, SysErr); raw_fd_ostream Out(OutputFilename, SysErr);
if (SysErr) { if (SysErr) {
WithColor::error() << "Couldn't open " << OutputFilename WithColor::error() << "Couldn't open " << OutputFilename
<< " for writing.\n"; << " for writing.\n";
return -1; return -1;
} }
return writeIfso(Stub, (Action == "write-ifs"), Out); return writeIfso(Stub, (Action == "write-ifs"), Out);
} }