llvm-bcanalyzer - added new option

[spetrovic]

Summary

This patch extends llvm-bcanalyzer tool with option "-print-fncs-and-globals". It prints function list and list of globals (and values of globals if the values are strings). It has similar output as GNU strings tool just input is LLVM IR file (.bc) instead object file.

[mehdi_amini]

Since you mention the GNU strings tool, the way we usually approach this is by providing a full replacement for the tool: i.e. llvm-strings that would work on any file format including bitcode. Are you interested in giving it a shot?

[spetrovic]

Initially my idea was to expand llvm-strings tool that works with bitcode file as you said, but I got suggestion to move this functionality to llvm-bcanalyzer ( https://reviews.llvm.org/D26959 ).

test/Other/bcanalyzer-funcs-globals.txt

+RUN: llvm-bcanalyzer -print-funcs-and-globals %S/Inputs/funcs-globals.bc | FileCheck -check-prefix=CHECK %s
+
+CHECK: funcs-globals.bc: 12343254354
+CHECK: funcs-globals.bc: Hello world
+CHECK-NEXT: funcs-globals.bc: main
+CHECK-NEXT: funcs-globals.bc: printf
+CHECK-NEXT: funcs-globals.bc: puts
 No newline at end of file

tools/llvm-bcanalyzer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BitReader
+  Core
   Support
   )
 
 add_llvm_tool(llvm-bcanalyzer
   llvm-bcanalyzer.cpp
 
   DEPENDS
   intrinsics_gen
   )

tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

 // the bitcode file (-dump option).
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Bitcode/LLVMBitCodes.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/Signals.h"

 //===----------------------------------------------------------------------===//
 // Bitcode specific analysis.
 //===----------------------------------------------------------------------===//
 
 static cl::opt<bool> NoHistogram("disable-histogram",
                                  cl::desc("Do not print per-code histogram"));
 
 static cl::opt<bool>
+PrintFuncAndGlobals("print-funcs-and-globals",
+                    cl::desc("Printing functions and global variables"));
+
+static cl::opt<bool>
 NonSymbolic("non-symbolic",
             cl::desc("Emit numeric info in dump even if"
                      " symbolic info is available"));
 
 static cl::opt<std::string>
   BlockInfoFilename("block-info",
                     cl::desc("Use the BLOCK_INFO from the given file"));
 
static bool openBitcodeFile(StringRef Path,
   if (Signature[0] == 'B' && Signature[1] == 'C' &&
       Signature[2] == 0x0 && Signature[3] == 0xC &&
       Signature[4] == 0xE && Signature[5] == 0xD)
     CurStreamType = LLVMIRBitstream;
 
   return false;
 }
 
+static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+  raw_ostream &OS = errs();
+  OS << (char *)Context << ": ";
+  switch (DI.getSeverity()) {
+  case DS_Error:
+    OS << "error: ";
+    break;
+  case DS_Warning:
+    OS << "warning: ";
+    break;
+  case DS_Remark:
+    OS << "remark: ";
+    break;
+  case DS_Note:
+    OS << "note: ";
+    break;
+  }
+}
+
+static void printGlobalVariablesAsString(const Module &Mod) {
+  const Module::GlobalListType &GlobalList = Mod.getGlobalList();
+  for (Module::const_global_iterator I = GlobalList.begin(),
+       E = GlobalList.end(); I != E; ++I) {
+    outs() << InputFilename + ": ";
+    outs() << I->getName() + "\n";
+    if (const ConstantDataArray *CA =
+        dyn_cast<ConstantDataArray>(I->getOperandList()->get())) {
+      if (!CA->isString())
+        continue;
+      StringRef PrintStr = CA->getAsString();
+      PrintStr = PrintStr.ltrim("\n");
+      size_t pos = PrintStr.find_first_of("\n");
+      PrintStr = PrintStr.substr(0, pos);
+      outs() << InputFilename  + ": ";
+      outs() << PrintStr + "\n";
+    }
+  }
+}
+
+static void printFunctionNamesAsString(const Module &Mod) {
+  const Module::FunctionListType &FunctionList = Mod.getFunctionList();
+  for (Module::const_iterator I = FunctionList.begin(),
+       E = FunctionList.end(); I!=E; ++I) {
+    outs() << InputFilename  + ": ";
+    outs() << I->getName() + "\n";
+  }
+}
+
 /// AnalyzeBitcode - Analyze the bitcode file specified by InputFilename.
 static int AnalyzeBitcode() {
   std::unique_ptr<MemoryBuffer> StreamBuffer;
   BitstreamCursor Stream;
   BitstreamBlockInfo BlockInfo;
   CurStreamTypeType CurStreamType;
   if (openBitcodeFile(InputFilename, StreamBuffer, Stream, CurStreamType))
     return true;
while (!Stream.AtEndOfStream()) {
 
     unsigned BlockID = Stream.ReadSubBlockID();
 
     if (ParseBlock(Stream, BlockInfo, BlockID, 0, CurStreamType))
       return true;
     ++NumTopBlocks;
   }
 
+  if (PrintFuncAndGlobals) {
+    ExitOnError ExitOnErr;
+    LLVMContext Context;
+    Context.setDiagnosticHandler(diagnosticHandler, nullptr);
+    std::unique_ptr<Module> M =
+          ExitOnErr(getOwningLazyBitcodeModule(std::move(StreamBuffer), Context,
+                                                  /*ShouldLazyLoadMetadata=*/true));
+    outs() << "Functions and globals of " << InputFilename << ":\n";
+    printGlobalVariablesAsString(*M);
+    printFunctionNamesAsString(*M);
+  }
+
   if (Dump) outs() << "\n\n";
 
   uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;
   // Print a summary of the read file.
   outs() << "Summary of " << InputFilename << ":\n";
   outs() << "         Total size: ";
   PrintSize(BufferSizeBits);
   outs() << "\n";