TargetLibraryInfo checker tool

[probinson]

Summary

A new tool that compares TargetLibraryInfo's opinion of the availability of library function calls against the functions actually exported by a specified set of libraries. Can be helpful in verifying the correctness of TLI for a given target, and avoid mishaps such as had to be addressed in D107509 and https://github.com/llvm/llvm-project/commit/94b4598d77fe0585a8a3bd2a798fc7ce15a6aa56

[probinson]

+folks who participated in D107509

[probinson]

+ @jhenderson for object-file-reading expertise.

[rengolin]

Hi Paul, thanks for submitting this, it looks super cool.

I've got a few comments on the syntax and options, but nothing too controversial.

The actual code looks super clean and easy to read, except for the SeparateMode part (to me, totally personal).

Perhaps it would be simpler if you always use an array of reports, and in separate mode, you populate the array one by one, but on joint mode you append to the first item, then report the array, however many items are there?

But none of that is really important, they're all just comments.

cheers,
--renato

llvm/docs/CommandGuide/llvm-tli-checker.rst

51

So, the syntax:

llvm-tli-checker ... --libdir=foo/bar a.o b.o c.o

will check against:

• foo/bar/a.o
• foo/bar/b.o
• foo/bar/c.o

If so, couldn't this just be foo/bar/* and let the shell expand it?

66

This feels like more of a separate functionality, for example, --list, then just being verbose.

I usually interpret verbose as showing the steps taken, not showing more information.

Instead, if I just want to list the symbols (for ex. for grepping), then do I need to create an empty object file and use --verbose?

75

llvm-tli-checker?

[probinson]

Sorry for the long delay, between CPPcon and putting together a dev-meeting talk I've been pretty distracted.

In D111358#3055417, @rengolin wrote:

The actual code looks super clean and easy to read, except for the SeparateMode part (to me, totally personal).

Perhaps it would be simpler if you always use an array of reports, and in separate mode, you populate the array one by one, but on joint mode you append to the first item, then report the array, however many items are there?

Yeah, that part is the bit I'm least happy about, it kind of just grew and probably could use a refactor now.
I invented separate mode so I could tell which library files had any libcalls in them at all, and reduce the fileset that I needed to look at. Maybe instead of separate mode, there could be a summary mode, that gave just the total number of matches per file. That would provide the functionality I actually needed.

llvm/docs/CommandGuide/llvm-tli-checker.rst

51

That could work. In my use case, the list of files to check is fixed, but I wanted to check against various releases, so it was easiest to put the list of files in a response file and then do --libdir=foo/bar @myliblist.txt for each release directory.
Also each foo/bar has many more files than just the libc/libm equivalents, and it's faster to look only at the specific files I want, so wildcarding would cost time and generate noise in the output.
I'd prefer to keep the option; I'll add a note about the response-file use case.

66

My inspiration was llvm-dwarfdump, where the default display shows you (for example) that an entity has a name attribute, and what that name is. In verbose mode, it also shows you details of the encoding, how it found the name. In that case, verbose does mean more information, so I did the same here.
Perhaps "print information" doesn't describe the behavior well, maybe "print results" is better? As it prints the results of all checks, not just the ones that don't match.
I could also see adding a --list option that didn't look at object files, but just dumped the info from TLI, would that be useful?

75

Oops

[probinson]

Updated the UI:
Removed --verbose, replaced with --report=[summary,discrepancy,full]
Added --dump-tli to get info about TLI without reference to a library file

Reworked the reporting code, to make it more compact and hopefully easier to follow.

[rengolin]

It's much clearer now, thanks for the updates!

This now looks good to me, but maybe wait a few days to make sure no one else has any further comments.

Thanks!

llvm/docs/CommandGuide/llvm-tli-checker.rst

51

I see, makes sense.

[rprichard]

Adding some Android folks to the subscriber list.

The motivating issue happened with Android (D107509). Maybe this test could be a useful way to ensure that LLVM doesn't assume a function is available that isn't actually in the NDK. To work, I think we'd want to test the LLVM toolchain with an NDK sysroot. For each arch-API combination, we'd want to run something like:

llvm-tli-checker --triple=${triple}${api} --libdir=${sysroot}/usr/lib/${triple}/${api} libc.so libm.so ../libc++_shared.so

I assume we need libc++_shared.so to provide the new/delete functions like LibFunc_Znwm.

[rprichard]

The motivating issue happened with Android (D107509).

(Well, the Android bug was one of the motivating bugs. The other bug the author mentioned happened with the PS4, https://github.com/llvm/llvm-project/commit/94b4598d77fe0585a8a3bd2a798fc7ce15a6aa56)

[MaskRay]

What this tool does fit a bit into the realm of llvm-ifs (it had a previous name "llvm-elfabi" D100139. I like "elfabi" better as "ifs" seems confusing). Would it be suitable to move the code there?

llvm/test/tools/llvm-tli-checker/ps4-tli-check.s

8

The relanded version (38be8f4057c1bf19fd02d08d6116e28983a49d8d) uses prebuilt shared objects Inputs/ps4-tli-check.right.so and Inputs/ps4-tli-check.wrong.so. For llvm/tools/* tools working on object files, we try very hard to avoid checking in new prebuilt files: they are opaque, difficult to update, and waste space.

It's recommended to use yaml2obj, like many tests in test/tools/llvm-objcopy and test/tools/llvm-readobj.

@jhenderson

llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp

61

https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

70

static

106

What does ?? do? It's not regular external name prefix (_Z). If it is organization-specific, there should be a comment.

116

This can just use free functions instead of inheriting from std::vector.

122

static

155

SDK may be an organization-specific term. The more widely used term is library.

162

static

168

I know that the file has settled on capitalized messages, but non-capitalized message are more common:
https://llvm.org/docs/CodingStandards.html#error-and-warning-messages

171

More common to omit const for cast and change auto * to const auto *

173

range-based for

189

llvm::enumerate

221

It is more common to define a warning function and avoid referencing WithColor in the main program.

[jhenderson]

llvm/docs/CommandGuide/llvm-tli-checker.rst

75

Copy-paste error :)

llvm/test/tools/llvm-tli-checker/ps4-tli-check.s

8

+1 to what MaskRay said. If you need guidance on what the YAML might look like, feel free to chat with me outside this review.

You also can't use lld in a RUN command outside the lld and cross-project-tests projects, since there's no guarantee it would have been built (llvm/tools tests only have access to the core llvm project components).

Apologies for not noticing these points earlier: this slipped off my radar, and I ended up looking at other stuff.

[probinson]

In D111358#3144735, @MaskRay wrote:

What this tool does fit a bit into the realm of llvm-ifs (it had a previous name "llvm-elfabi" D100139. I like "elfabi" better as "ifs" seems confusing). Would it be suitable to move the code there?

I don't see any entry in https://llvm.org/docs/CommandGuide/index.html for llvm-ifs, and there is no description in llvm-ifs.cpp so it is hard to know what it does. I do see comments about "emitting stubs" which is not at all what this tool does, so I'm inclined to say No, combining them is not suitable.

See D114478 for code and test changes in response to this review.

llvm/test/tools/llvm-tli-checker/ps4-tli-check.s

8

I'll point out that the assembler source, with instructions for regenerating the prebuilt objects, is in the relanded patch, so there's no trouble to recreate them if necessary.

But I did get yaml2obj to do what I need, and the net file size is a small decrease, so I've replaced the test.

llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp

61

Fixed comment

106

All names in the TLI set are external. _Z indicates an Itanium-style mangled name; ?? is the prefix for Windows mangling.
I've added a comment to that effect.

116

I think this is better OO design.

155

SDK is a common industry term. I didn't use "library" because the APIs may be implemented across several libraries within an SDK.

171

Okay.

173

I thought I had tried that and it didn't work, but it does now; changed.

189

I tried that, but the iterator doesn't have a reference member that llvm::enumerate appears to need.

221

This is not in the main program.

llvm/docs/CommandGuide/index.rst

.. toctree::
    lldb-tblgen
    llvm-tblgen
    mlir-tblgen
    lit
    llvm-exegesis
    llvm-locstats
    llvm-pdbutil
    llvm-profgen
+   llvm-tli-checker

llvm/docs/CommandGuide/llvm-tli-checker.rst

+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=<directory>
+
+  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=<level>
+
+  The amount of information to report.  <level> 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=<triple>
+
+  The triple to use for initializing TargetLibraryInfo.
+
+.. option:: @<FILE>
+
+ Read command-line options and/or library names from response file `<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.

llvm/test/tools/llvm-tli-checker/ps4-tli-check.s

+# 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
+

llvm/tools/llvm-tli-checker/CMakeLists.txt

+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
+  )

llvm/tools/llvm-tli-checker/Opts.td

+include "llvm/Option/OptParser.td"
+
+class F<string name, string help> : Flag<["--"], name>, HelpText<help>;
+multiclass Eq<string name, string metavar, string help> {
+  def NAME #_EQ : Joined<["--"], name #"=">,
+                  HelpText<help>, MetaVarName<metavar>;
+  def : Separate<["--"], name>, Alias<!cast<Joined>(NAME #_EQ)>;
+}
+
+def help : F<"help", "Display available options">;
+def : Flag<["-"], "h">, HelpText<"Alias for --help">, Alias<help>;
+def dump_tli : F<"dump-tli", "Dump TLI's list of functions and whether they are available">;
+defm triple : Eq<"triple", "<triple>", "Target triple">;
+defm libdir : Eq<"libdir", "<directory>", "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">;

llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp

+//===-- 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<T>, so make it easy
+// to ignore those.
+template <typename T> T unwrapIgnoreError(Expected<T> 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<StringRef> NameOrErr = C.getName();
+  if (NameOrErr)
+    ChildName = std::string(NameOrErr.get());
+  else {
+    // Ignore the name-fetch error, just report the index.
+    consumeError(NameOrErr.takeError());
+    ChildName = "<file index: " + std::to_string(Index) + ">";
+  }
+
+  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<std::pair<StringRef, bool>> {
+  // 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<bool> {
+  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<const ELFObjectFileBase>(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<std::unique_ptr<object::Binary>> 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<ObjectFile>(&*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<Binary> OBinary = std::move(*ExpectedBinary);
+  Binary &Binary = *OBinary.getBinary();
+  size_t Precount = size();
+  if (Archive *A = dyn_cast<Archive>(&Binary))
+    populateFromArchive(A);
+  else if (ObjectFile *O = dyn_cast<ObjectFile>(&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<std::string> 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<ReportKind>(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";
+    }
+  }
+}