diff --git a/llvm/docs/CommandGuide/index.rst b/llvm/docs/CommandGuide/index.rst --- a/llvm/docs/CommandGuide/index.rst +++ b/llvm/docs/CommandGuide/index.rst @@ -82,3 +82,4 @@ llvm-locstats llvm-pdbutil llvm-profgen + llvm-tli-checker diff --git a/llvm/docs/CommandGuide/llvm-tli-checker.rst b/llvm/docs/CommandGuide/llvm-tli-checker.rst new file mode 100644 --- /dev/null +++ b/llvm/docs/CommandGuide/llvm-tli-checker.rst @@ -0,0 +1,85 @@ +llvm-tli-checker - TargetLibraryInfo vs library checker +======================================================= + +.. program:: llvm-tli-checker + +SYNOPSIS +-------- + +:program:`llvm-tli-checker` [*options*] [*library-file...*] + +DESCRIPTION +----------- + +:program:`llvm-tli-checker` compares TargetLibraryInfo's opinion of the +availability of library functions against the set of functions exported +by the specified library files, reporting any disagreements between TLI's +opinion and whether the function is actually present. This is primarily +useful for vendors to ensure the TLI for their target is correct, and +the compiler will not "optimize" some code sequence into a library call +that is not actually available. + +EXAMPLE +------- + +.. code-block:: console + + $ llvm-tli-checker --triple x86_64-scei-ps4 example.so + TLI knows 466 symbols, 235 available for 'x86_64-scei-ps4' + + Looking for symbols in 'example.so' + Found 235 global function symbols in 'example.so' + Found a grand total of 235 library symbols + << TLI yes SDK no: '_ZdaPv' aka operator delete[](void*) + >> TLI no SDK yes: '_ZdaPvj' aka operator delete[](void*, unsigned int) + << Total TLI yes SDK no: 1 + >> Total TLI no SDK yes: 1 + == Total TLI yes SDK yes: 234 + FAIL: LLVM TLI doesn't match SDK libraries. + +OPTIONS +------- + +.. option:: --dump-tli + + Print "available"/"not available" for each library function, according to + TargetLibraryInfo's information for the specified triple, and exit. This + option does not read any input files. + +.. option:: --help, -h + + Print a summary of command line options and exit. + +.. option:: --libdir= + + A base directory to prepend to each library file path. This is handy + when there are a number of library files all in the same directory, or + a list of input filenames are kept in a response file. + +.. option:: --report= + + The amount of information to report. can be summary, discrepancy, + or full. A summary report gives only the count of matching and mis-matching + symbols; discrepancy lists the mis-matching symbols; and full lists all + symbols known to TLI, matching or mis-matching. The default is discrepancy. + +.. option:: --separate + + Read and report a summary for each library file separately. This can be + useful to identify library files that don't contribute anything that TLI + knows about. Implies --report=summary (can be overridden). + +.. option:: --triple= + + The triple to use for initializing TargetLibraryInfo. + +.. option:: @ + + Read command-line options and/or library names from response file ``. + +EXIT STATUS +----------- + +:program:`llvm-tli-checker` returns 0 even if there are mismatches. It returns a +non-zero exit code if there is an unrecognized option, or no input files are +provided. diff --git a/llvm/test/tools/llvm-tli-checker/ps4-tli-check.s b/llvm/test/tools/llvm-tli-checker/ps4-tli-check.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-tli-checker/ps4-tli-check.s @@ -0,0 +1,288 @@ +# REQUIRES: x86-registered-target +# +# RUN: llvm-mc --triple=x86_64-scei-ps4 --filetype=obj %s -o %t.o +# RUN: ld.lld --shared %t.o -o %t.so +# RUN: llvm-tli-checker --triple=x86_64-scei-ps4 %t.so | FileCheck %s +# +# RUN: llvm-mc --triple=x86_64-scei-ps4 --defsym WRONG=1 --filetype=obj %s -o %t2.o +# RUN: ld.lld --shared %t2.o -o %t2.so +# RUN: echo %t2.so > %t2.txt +# RUN: llvm-tli-checker --triple x86_64-scei-ps4 @%t2.txt | \ +# RUN: FileCheck %s --check-prefix=WRONG_SUMMARY --check-prefix=WRONG_DETAIL \ +# RUN: --implicit-check-not="==" --implicit-check-not="<<" --implicit-check-not=">>" +# RUN: llvm-tli-checker --triple x86_64-scei-ps4 @%t2.txt --report=summary | \ +# RUN: FileCheck %s --check-prefix=WRONG_SUMMARY \ +# RUN: --implicit-check-not="==" --implicit-check-not="<<" --implicit-check-not=">>" +## --separate implies --report=summary. +# RUN: llvm-tli-checker --triple x86_64-scei-ps4 @%t2.txt --separate | \ +# RUN: FileCheck %s --check-prefix=WRONG_SUMMARY \ +# RUN: --implicit-check-not="==" --implicit-check-not="<<" --implicit-check-not=">>" +# +# RUN: llvm-tli-checker --triple x86_64-scei-ps4 --dump-tli > %t3.txt +# RUN: FileCheck %s --check-prefix=AVAIL --input-file %t3.txt +# RUN: FileCheck %s --check-prefix=UNAVAIL --input-file %t3.txt +# +# CHECK: << Total TLI yes SDK no: 0 +# CHECK: >> Total TLI no SDK yes: 0 +# CHECK: == Total TLI yes SDK yes: 235 +# +# WRONG_DETAIL: << TLI yes SDK no : '_ZdaPv' +# WRONG_DETAIL: >> TLI no SDK yes: '_ZdaPvj' +# WRONG_SUMMARY: << Total TLI yes SDK no: 1{{$}} +# WRONG_SUMMARY: >> Total TLI no SDK yes: 1{{$}} +# WRONG_SUMMARY: == Total TLI yes SDK yes: 234 +# +## The -COUNT suffix doesn't care if there are too many matches, so check +## the exact count first; the two directives should add up to that. +# AVAIL: TLI knows 466 symbols, 235 available +# AVAIL-COUNT-235: {{^}} available +# UNAVAIL-COUNT-231: not available + +.macro defname name +.globl \name +.type \name ,@function +\name : nop +.endm + +.text +# For the WRONG case, omit _ZdaPv and include _ZdaPvj. +.ifdef WRONG +defname _ZdaPvj +.else +defname _ZdaPv +.endif +defname _ZdaPvRKSt9nothrow_t +defname _ZdaPvSt11align_val_t +defname _ZdaPvSt11align_val_tRKSt9nothrow_t +defname _ZdaPvm +defname _ZdaPvmSt11align_val_t +defname _ZdlPv +defname _ZdlPvRKSt9nothrow_t +defname _ZdlPvSt11align_val_t +defname _ZdlPvSt11align_val_tRKSt9nothrow_t +defname _ZdlPvm +defname _ZdlPvmSt11align_val_t +defname _Znam +defname _ZnamRKSt9nothrow_t +defname _ZnamSt11align_val_t +defname _ZnamSt11align_val_tRKSt9nothrow_t +defname _Znwm +defname _ZnwmRKSt9nothrow_t +defname _ZnwmSt11align_val_t +defname _ZnwmSt11align_val_tRKSt9nothrow_t +defname __cxa_atexit +defname __cxa_guard_abort +defname __cxa_guard_acquire +defname __cxa_guard_release +defname abs +defname acos +defname acosf +defname acosh +defname acoshf +defname acoshl +defname acosl +defname aligned_alloc +defname asin +defname asinf +defname asinh +defname asinhf +defname asinhl +defname asinl +defname atan +defname atan2 +defname atan2f +defname atan2l +defname atanf +defname atanh +defname atanhf +defname atanhl +defname atanl +defname atof +defname atoi +defname atol +defname atoll +defname calloc +defname cbrt +defname cbrtf +defname cbrtl +defname ceil +defname ceilf +defname ceill +defname clearerr +defname copysign +defname copysignf +defname copysignl +defname cos +defname cosf +defname cosh +defname coshf +defname coshl +defname cosl +defname exp +defname exp2 +defname exp2f +defname exp2l +defname expf +defname expl +defname expm1 +defname expm1f +defname expm1l +defname fabs +defname fabsf +defname fabsl +defname fclose +defname fdopen +defname feof +defname ferror +defname fflush +defname fgetc +defname fgetpos +defname fgets +defname fileno +defname floor +defname floorf +defname floorl +defname fmax +defname fmaxf +defname fmaxl +defname fmin +defname fminf +defname fminl +defname fmod +defname fmodf +defname fmodl +defname fopen +defname fprintf +defname fputc +defname fputs +defname fread +defname free +defname frexp +defname frexpf +defname frexpl +defname fscanf +defname fseek +defname fsetpos +defname ftell +defname fwrite +defname getc +defname getchar +defname gets +defname isdigit +defname labs +defname ldexp +defname ldexpf +defname ldexpl +defname llabs +defname log +defname log10 +defname log10f +defname log10l +defname log1p +defname log1pf +defname log1pl +defname log2 +defname log2f +defname log2l +defname logb +defname logbf +defname logbl +defname logf +defname logl +defname malloc +defname memalign +defname memchr +defname memcmp +defname memcpy +defname memmove +defname memset +defname mktime +defname modf +defname modff +defname modfl +defname nearbyint +defname nearbyintf +defname nearbyintl +defname perror +defname posix_memalign +defname pow +defname powf +defname powl +defname printf +defname putc +defname putchar +defname puts +defname qsort +defname realloc +defname remainder +defname remainderf +defname remainderl +defname remove +defname rewind +defname rint +defname rintf +defname rintl +defname round +defname roundf +defname roundl +defname scanf +defname setbuf +defname setvbuf +defname sin +defname sinf +defname sinh +defname sinhf +defname sinhl +defname sinl +defname snprintf +defname sprintf +defname sqrt +defname sqrtf +defname sqrtl +defname sscanf +defname strcasecmp +defname strcat +defname strchr +defname strcmp +defname strcoll +defname strcpy +defname strcspn +defname strdup +defname strlen +defname strncasecmp +defname strncat +defname strncmp +defname strncpy +defname strpbrk +defname strrchr +defname strspn +defname strstr +defname strtod +defname strtof +defname strtok +defname strtok_r +defname strtol +defname strtold +defname strtoll +defname strtoul +defname strtoull +defname strxfrm +defname tan +defname tanf +defname tanh +defname tanhf +defname tanhl +defname tanl +defname trunc +defname truncf +defname truncl +defname ungetc +defname vfprintf +defname vfscanf +defname vprintf +defname vscanf +defname vsnprintf +defname vsprintf +defname vsscanf +defname wcslen + diff --git a/llvm/tools/llvm-tli-checker/CMakeLists.txt b/llvm/tools/llvm-tli-checker/CMakeLists.txt new file mode 100644 --- /dev/null +++ b/llvm/tools/llvm-tli-checker/CMakeLists.txt @@ -0,0 +1,26 @@ +set(LLVM_LINK_COMPONENTS + Analysis + BinaryFormat + BitReader + BitstreamReader + Core + Demangle + MC + MCParser + Object + Option + Remarks + Support + TextAPI + ) + +set(LLVM_TARGET_DEFINITIONS Opts.td) +tablegen(LLVM Opts.inc -gen-opt-parser-defs) +add_public_tablegen_target(TLICheckerOptsTableGen) + +add_llvm_tool(llvm-tli-checker + llvm-tli-checker.cpp + + DEPENDS + TLICheckerOptsTableGen + ) diff --git a/llvm/tools/llvm-tli-checker/Opts.td b/llvm/tools/llvm-tli-checker/Opts.td new file mode 100644 --- /dev/null +++ b/llvm/tools/llvm-tli-checker/Opts.td @@ -0,0 +1,16 @@ +include "llvm/Option/OptParser.td" + +class F : Flag<["--"], name>, HelpText; +multiclass Eq { + def NAME #_EQ : Joined<["--"], name #"=">, + HelpText, MetaVarName; + def : Separate<["--"], name>, Alias(NAME #_EQ)>; +} + +def help : F<"help", "Display available options">; +def : Flag<["-"], "h">, HelpText<"Alias for --help">, Alias; +def dump_tli : F<"dump-tli", "Dump TLI's list of functions and whether they are available">; +defm triple : Eq<"triple", "", "Target triple">; +defm libdir : Eq<"libdir", "", "Root directory for finding library files">; +def separate : F<"separate", "Report on each library file separately">; +def report_EQ : Joined<["--"], "report=">, HelpText<"Level of detail to report">, Values<"summary,discrepancy,full">; diff --git a/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp b/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp new file mode 100644 --- /dev/null +++ b/llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp @@ -0,0 +1,357 @@ +//===-- llvm-tli-checker.cpp - Compare TargetLibraryInfo to SDK libraries -===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/ADT/Triple.h" +#include "llvm/Analysis/TargetLibraryInfo.h" +#include "llvm/Config/llvm-config.h" +#include "llvm/Demangle/Demangle.h" +#include "llvm/Object/Archive.h" +#include "llvm/Object/ELFObjectFile.h" +#include "llvm/Option/ArgList.h" +#include "llvm/Option/Option.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/InitLLVM.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/WithColor.h" + +using namespace llvm; +using namespace llvm::object; + +// Command-line option boilerplate. +namespace { +enum ID { + OPT_INVALID = 0, // This is not an option ID. +#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ + HELPTEXT, METAVAR, VALUES) \ + OPT_##ID, +#include "Opts.inc" +#undef OPTION +}; + +#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE; +#include "Opts.inc" +#undef PREFIX + +const opt::OptTable::Info InfoTable[] = { +#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ + HELPTEXT, METAVAR, VALUES) \ + { \ + PREFIX, NAME, HELPTEXT, \ + METAVAR, OPT_##ID, opt::Option::KIND##Class, \ + PARAM, FLAGS, OPT_##GROUP, \ + OPT_##ALIAS, ALIASARGS, VALUES}, +#include "Opts.inc" +#undef OPTION +}; + +class TLICheckerOptTable : public opt::OptTable { +public: + TLICheckerOptTable() : OptTable(InfoTable) {} +}; +} // namespace + +// We have three levels of reporting. +enum class ReportKind { + Error, // For argument parsing errors. + Summary, // Report counts but not details. + Discrepancy, // Report where TLI and the library differ. + Full // Report for every known-to-TLI function. +}; + +// Most of the ObjectFile interfaces return an Expected, so make it easy +// to ignore those. +template T unwrapIgnoreError(Expected E) { + if (E) + return std::move(*E); + // Sink the error and return a nothing value. + consumeError(E.takeError()); + return T(); +} + +static void fail(const Twine &Message) { + WithColor::error() << Message << '\n'; + exit(EXIT_FAILURE); +} + +// Some problem occurred with an archive member; complain and continue. +static void reportArchiveChildIssue(const object::Archive::Child &C, int Index, + StringRef ArchiveFilename) { + // First get the member name. + std::string ChildName; + Expected NameOrErr = C.getName(); + if (NameOrErr) + ChildName = std::string(NameOrErr.get()); + else { + // Ignore the name-fetch error, just report the index. + consumeError(NameOrErr.takeError()); + ChildName = ""; + } + + WithColor::warning() << ArchiveFilename << "(" << ChildName + << "): member is not usable\n"; +} + +// Return Name, and if Name is mangled, append "aka" and the demangled name. +static std::string PrintableName(StringRef Name) { + std::string OutputName = "'"; + OutputName += Name; + OutputName += "'"; + if (Name.startswith("_Z") || Name.startswith("??")) { + OutputName += " aka "; + OutputName += demangle(Name.str()); + } + return OutputName; +} + +// Store all the names that TargetLibraryInfo knows about; the bool indicates +// whether TLI has it marked as "available" for the target of interest. +// This is a vector to preserve the sorted order for better reporting. +struct TLINameList : std::vector> { + // Record all the TLI info in the vector. + void initialize(StringRef TargetTriple); + // Print out what we found. + void dump(); +}; +TLINameList TLINames; + +void TLINameList::initialize(StringRef TargetTriple) { + Triple T(TargetTriple); + TargetLibraryInfoImpl TLII(T); + TargetLibraryInfo TLI(TLII); + + reserve(LibFunc::NumLibFuncs); + size_t NumAvailable = 0; + for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) { + LibFunc LF = (LibFunc)FI; + bool Available = TLI.has(LF); + // getName returns names only for available funcs. + TLII.setAvailable(LF); + emplace_back(TLI.getName(LF), Available); + if (Available) + ++NumAvailable; + } + outs() << "TLI knows " << LibFunc::NumLibFuncs << " symbols, " << NumAvailable + << " available for '" << TargetTriple << "'\n"; +} + +void TLINameList::dump() { + // Assume this gets called after initialize(), so we have the above line of + // output as a header. So, for example, no need to repeat the triple. + for (auto &TLIName : TLINames) { + outs() << (TLIName.second ? " " : "not ") + << "available: " << PrintableName(TLIName.first) << '\n'; + } +} + +// Store all the exported symbol names we found in the input libraries. +// We use a map to get hashed lookup speed; the bool is meaningless. +class SDKNameMap : public StringMap { + void populateFromObject(ObjectFile *O); + void populateFromArchive(Archive *A); + +public: + void populateFromFile(StringRef LibDir, StringRef LibName); +}; +SDKNameMap SDKNames; + +// Given an ObjectFile, extract the global function symbols. +void SDKNameMap::populateFromObject(ObjectFile *O) { + // FIXME: Support COFF. + if (!O->isELF()) { + WithColor::warning() << "Only ELF-format files are supported\n"; + return; + } + auto *ELF = cast(O); + + for (auto I = ELF->getDynamicSymbolIterators().begin(); + I != ELF->getDynamicSymbolIterators().end(); ++I) { + // We want only global function symbols. + SymbolRef::Type Type = unwrapIgnoreError(I->getType()); + uint32_t Flags = unwrapIgnoreError(I->getFlags()); + StringRef Name = unwrapIgnoreError(I->getName()); + if (Type == SymbolRef::ST_Function && (Flags & SymbolRef::SF_Global)) + insert({Name, true}); + } +} + +// Unpack an archive and populate from the component object files. +// This roughly imitates dumpArchive() from llvm-objdump.cpp. +void SDKNameMap::populateFromArchive(Archive *A) { + Error Err = Error::success(); + int Index = -1; + for (auto &C : A->children(Err)) { + ++Index; + Expected> ChildOrErr = C.getAsBinary(); + if (!ChildOrErr) { + if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) { + // Issue a generic warning. + consumeError(std::move(E)); + reportArchiveChildIssue(C, Index, A->getFileName()); + } + continue; + } + if (ObjectFile *O = dyn_cast(&*ChildOrErr.get())) + populateFromObject(O); + // Ignore non-object archive members. + } + if (Err) + WithColor::defaultErrorHandler(std::move(Err)); +} + +// Unpack a library file and extract the global function names. +void SDKNameMap::populateFromFile(StringRef LibDir, StringRef LibName) { + // Pick an arbitrary but reasonable default size. + SmallString<255> Filepath(LibDir); + sys::path::append(Filepath, LibName); + if (!sys::fs::exists(Filepath)) { + WithColor::warning() << "Could not find '" << StringRef(Filepath) << "'\n"; + return; + } + outs() << "\nLooking for symbols in '" << StringRef(Filepath) << "'\n"; + auto ExpectedBinary = createBinary(Filepath); + if (!ExpectedBinary) { + // FIXME: Report this better. + WithColor::defaultWarningHandler(ExpectedBinary.takeError()); + return; + } + OwningBinary OBinary = std::move(*ExpectedBinary); + Binary &Binary = *OBinary.getBinary(); + size_t Precount = size(); + if (Archive *A = dyn_cast(&Binary)) + populateFromArchive(A); + else if (ObjectFile *O = dyn_cast(&Binary)) + populateFromObject(O); + else { + WithColor::warning() << "Not an Archive or ObjectFile: '" + << StringRef(Filepath) << "'\n"; + return; + } + if (Precount == size()) + WithColor::warning() << "No symbols found in '" << StringRef(Filepath) + << "'\n"; + else + outs() << "Found " << size() - Precount << " global function symbols in '" + << StringRef(Filepath) << "'\n"; +} + +int main(int argc, char *argv[]) { + InitLLVM X(argc, argv); + BumpPtrAllocator A; + StringSaver Saver(A); + TLICheckerOptTable Tbl; + opt::InputArgList Args = Tbl.parseArgs(argc, argv, OPT_UNKNOWN, Saver, + [&](StringRef Msg) { fail(Msg); }); + + if (Args.hasArg(OPT_help)) { + std::string Usage(argv[0]); + Usage += " [options] library-file [library-file...]"; + Tbl.printHelp(outs(), Usage.c_str(), + "LLVM TargetLibraryInfo versus SDK checker"); + outs() << "\nPass @FILE as argument to read options or library names from " + "FILE.\n"; + return 0; + } + + TLINames.initialize(Args.getLastArgValue(OPT_triple_EQ)); + + // --dump-tli doesn't require any input files. + if (Args.hasArg(OPT_dump_tli)) { + TLINames.dump(); + return 0; + } + + std::vector LibList = Args.getAllArgValues(OPT_INPUT); + if (LibList.empty()) { + WithColor::error() << "No input files\n"; + exit(EXIT_FAILURE); + } + StringRef LibDir = Args.getLastArgValue(OPT_libdir_EQ); + bool SeparateMode = Args.hasArg(OPT_separate); + + ReportKind ReportLevel = + SeparateMode ? ReportKind::Summary : ReportKind::Discrepancy; + if (const opt::Arg *A = Args.getLastArg(OPT_report_EQ)) { + ReportLevel = StringSwitch(A->getValue()) + .Case("summary", ReportKind::Summary) + .Case("discrepancy", ReportKind::Discrepancy) + .Case("full", ReportKind::Full) + .Default(ReportKind::Error); + if (ReportLevel == ReportKind::Error) { + WithColor::error() << "invalid option for --report: " << A->getValue(); + exit(EXIT_FAILURE); + } + } + + for (size_t I = 0; I < LibList.size(); ++I) { + // In SeparateMode we report on input libraries individually; otherwise + // we do one big combined search. Reading to the end of LibList here + // will cause the outer while loop to terminate cleanly. + if (SeparateMode) { + SDKNames.clear(); + SDKNames.populateFromFile(LibDir, LibList[I]); + if (SDKNames.empty()) + continue; + } else { + do + SDKNames.populateFromFile(LibDir, LibList[I]); + while (++I < LibList.size()); + if (SDKNames.empty()) { + WithColor::error() << "NO symbols found!\n"; + break; + } + outs() << "Found a grand total of " << SDKNames.size() + << " library symbols\n"; + } + unsigned TLIdoesSDKdoesnt = 0; + unsigned TLIdoesntSDKdoes = 0; + unsigned TLIandSDKboth = 0; + unsigned TLIandSDKneither = 0; + for (auto &TLIName : TLINames) { + bool TLIHas = TLIName.second; + bool SDKHas = SDKNames.count(TLIName.first) == 1; + int Which = int(TLIHas) * 2 + int(SDKHas); + switch (Which) { + case 0: ++TLIandSDKneither; break; + case 1: ++TLIdoesntSDKdoes; break; + case 2: ++TLIdoesSDKdoesnt; break; + case 3: ++TLIandSDKboth; break; + } + // If the results match, report only if user requested a full report. + ReportKind Threshold = + TLIHas == SDKHas ? ReportKind::Full : ReportKind::Discrepancy; + if (Threshold <= ReportLevel) { + constexpr char YesNo[2][4] = {"no ", "yes"}; + constexpr char Indicator[4][3] = {"!!", ">>", "<<", "=="}; + outs() << Indicator[Which] << " TLI " << YesNo[TLIHas] << " SDK " + << YesNo[SDKHas] << ": " << PrintableName(TLIName.first) << '\n'; + } + } + + assert(TLIandSDKboth + TLIandSDKneither + TLIdoesSDKdoesnt + + TLIdoesntSDKdoes == + LibFunc::NumLibFuncs); + outs() << "<< Total TLI yes SDK no: " << TLIdoesSDKdoesnt + << "\n>> Total TLI no SDK yes: " << TLIdoesntSDKdoes + << "\n== Total TLI yes SDK yes: " << TLIandSDKboth; + if (TLIandSDKboth == 0) { + outs() << " *** NO TLI SYMBOLS FOUND"; + if (SeparateMode) + outs() << " in '" << LibList[I] << "'"; + } + outs() << '\n'; + + if (!SeparateMode) { + if (TLIdoesSDKdoesnt == 0 && TLIdoesntSDKdoes == 0) + outs() << "PASS: LLVM TLI matched SDK libraries successfully.\n"; + else + outs() << "FAIL: LLVM TLI doesn't match SDK libraries.\n"; + } + } +}