llvm-strings: introduce basic strings tool

This is a replacement to binutils' string tool.  It prints strings found in a
binary (object file, executable, or archive library).  It is rather bare and
not functionally equivalent, however, it lays the groundwork necessary for the
strings tool, enabling iterative development of features to reach feature
parity.

llvm-svn: 286556

Author: compnerd

llvm/tools/llvm-strings/CMakeLists.txt

@@ -0,0 +1,8 @@
+set(LLVM_LINK_COMPONENTS
+  Object
+  )
+
+add_llvm_tool(llvm-strings
+  llvm-strings.cpp
+  )
+

llvm/tools/llvm-strings/LLVMBuild.txt

@@ -0,0 +1,22 @@
+;===- ./tools/llvm-strings/LLVMBuild.txt -----------------------*- Conf -*--===;
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[component_0]
+type = Tool
+name = llvm-strings
+parent = Tools
+required_libraries = Archive Object

llvm/tools/llvm-strings/llvm-strings.cpp

@@ -0,0 +1,120 @@
+//===-- llvm-strings.cpp - Printable String dumping utility ---------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This program is a utility that works like binutils "strings", that is, it
+// prints out printable strings in a binary, objdump, or archive file.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/PrettyStackTrace.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/Signals.h"
+#include <string>
+
+using namespace llvm;
+using namespace llvm::object;
+
+static cl::list<std::string> InputFileNames(cl::Positional,
+                                            cl::desc("<input object files>"),
+                                            cl::ZeroOrMore);
+
+static void dump(raw_ostream &OS, StringRef Contents) {
+  const char *S = nullptr;
+  for (const char *P = Contents.begin(), *E = Contents.end(); P < E; ++P) {
+    if (std::isgraph(*P) || std::isblank(*P)) {
+      if (S == nullptr)
+        S = P;
+    } else if (S) {
+      if (P - S > 3)
+        OS << StringRef(S, P - S) << '\n';
+      S = nullptr;
+    }
+  }
+}
+
+namespace {
+class Strings {
+  LLVMContext Context;
+  raw_ostream &OS;
+
+  void dump(const ObjectFile *O) {
+    for (const auto &S : O->sections()) {
+      StringRef Contents;
+      if (!S.getContents(Contents))
+        ::dump(OS, Contents);
+    }
+  }
+
+  void dump(const Archive *A) {
+    Error E;
+    for (auto &Element : A->children(E)) {
+      if (Expected<std::unique_ptr<Binary>> Child =
+              Element.getAsBinary(&Context)) {
+        dump(dyn_cast<ObjectFile>(&**Child));
+      } else {
+        if (auto E = isNotObjectErrorInvalidFileType(Child.takeError())) {
+          errs() << A->getFileName();
+          if (Expected<StringRef> Name = Element.getName())
+            errs() << '(' << *Name << ')';
+          logAllUnhandledErrors(std::move(E), errs(), "");
+          errs() << '\n';
+        }
+      }
+    }
+    static_cast<bool>(E);
+  }
+
+public:
+  Strings(raw_ostream &S) : OS(S) {}
+
+  void scan(StringRef File) {
+    ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
+        MemoryBuffer::getFileOrSTDIN(File);
+    if (std::error_code EC = Buffer.getError()) {
+      errs() << File << ": " << EC.message() << '\n';
+      return;
+    }
+
+    if (Expected<std::unique_ptr<Binary>> B =
+            createBinary(Buffer.get()->getMemBufferRef(), &Context)) {
+      if (auto *A = dyn_cast<Archive>(&**B))
+        return dump(A);
+      if (auto *O = dyn_cast<ObjectFile>(&**B))
+        return dump(O);
+      ::dump(OS, Buffer.get()->getMemBufferRef().getBuffer());
+    } else {
+      consumeError(B.takeError());
+      ::dump(OS, Buffer.get()->getMemBufferRef().getBuffer());
+    }
+  }
+};
+}
+
+int main(int argc, char **argv) {
+  sys::PrintStackTraceOnErrorSignal(argv[0]);
+  PrettyStackTraceProgram X(argc, argv);
+
+  cl::ParseCommandLineOptions(argc, argv, "llvm string dumper\n");
+
+  if (InputFileNames.empty())
+    InputFileNames.push_back("-");
+
+  Strings S(llvm::outs());
+  std::for_each(InputFileNames.begin(), InputFileNames.end(),
+                [&S](StringRef F) { S.scan(F); });
+  return EXIT_SUCCESS;
+}
+