//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include <getopt.h>
#include <stdint.h>
#include <stdlib.h>

#if defined(__APPLE__)
#include <LLDB/LLDB.h>
#else
#include "LLDB/SBBlock.h"
#include "LLDB/SBCompileUnit.h"
#include "LLDB/SBDebugger.h"
#include "LLDB/SBFunction.h"
#include "LLDB/SBModule.h"
#include "LLDB/SBProcess.h"
#include "LLDB/SBStream.h"
#include "LLDB/SBSymbol.h"
#include "LLDB/SBTarget.h"
#include "LLDB/SBThread.h"
#endif

#include <string>

using namespace lldb;

//----------------------------------------------------------------------
// This quick sample code shows how to create a debugger instance and
// create an executable target without adding dependent shared
// libraries. It will then set a regular expression breakpoint to get
// breakpoint locations for all functions in the module, and use the
// locations to extract the symbol context for each location. Then it
// dumps all // information about the function: its name, file address
// range, the return type (if any), and all argument types.
//
// To build the program, type (while in this directory):
//
//    $ make
//
// then to run this on MacOSX, specify the path to your LLDB.framework
// library using the DYLD_FRAMEWORK_PATH option and run the executable
//
//    $ DYLD_FRAMEWORK_PATH=/Volumes/data/lldb/tot/build/Debug ./a.out
//    executable_path1 [executable_path2 ...]
//----------------------------------------------------------------------
class LLDBSentry {
public:
  LLDBSentry() {
    // Initialize LLDB
    SBDebugger::Initialize();
  }
  ~LLDBSentry() {
    // Terminate LLDB
    SBDebugger::Terminate();
  }
};

static struct option g_long_options[] = {
    {"arch", required_argument, NULL, 'a'},
    {"canonical", no_argument, NULL, 'c'},
    {"extern", no_argument, NULL, 'x'},
    {"help", no_argument, NULL, 'h'},
    {"platform", required_argument, NULL, 'p'},
    {"verbose", no_argument, NULL, 'v'},
    {NULL, 0, NULL, 0}};

#define PROGRAM_NAME "lldb-functions"
void usage() {
  puts("NAME\n"
       "    " PROGRAM_NAME
       " -- extract all function signatures from one or more binaries.\n"
       "\n"
       "SYNOPSIS\n"
       "    " PROGRAM_NAME " [[--arch=<ARCH>] [--platform=<PLATFORM>] "
                           "[--verbose] [--help] [--canonical] --] <PATH> "
                           "[<PATH>....]\n"
       "\n"
       "DESCRIPTION\n"
       "    Loads the executable pointed to by <PATH> and dumps complete "
       "signatures for all functions that have debug information.\n"
       "\n"
       "EXAMPLE\n"
       "   " PROGRAM_NAME " --arch=x86_64 /usr/lib/dyld\n");
  exit(0);
}
int main(int argc, char const *argv[]) {
  // Use a sentry object to properly initialize/terminate LLDB.
  LLDBSentry sentry;

  SBDebugger debugger(SBDebugger::Create());

  // Create a debugger instance so we can create a target
  if (!debugger.IsValid())
    fprintf(stderr, "error: failed to create a debugger object\n");

  bool show_usage = false;
  bool verbose = false;
  bool canonical = false;
  bool external_only = false;
  const char *arch = NULL;
  const char *platform = NULL;
  std::string short_options("h?");
  for (const struct option *opt = g_long_options; opt->name; ++opt) {
    if (isprint(opt->val)) {
      short_options.append(1, (char)opt->val);
      switch (opt->has_arg) {
      case no_argument:
        break;
      case required_argument:
        short_options.append(1, ':');
        break;
      case optional_argument:
        short_options.append(2, ':');
        break;
      }
    }
  }
#ifdef __GLIBC__
  optind = 0;
#else
  optreset = 1;
  optind = 1;
#endif
  char ch;
  while ((ch = getopt_long_only(argc, (char *const *)argv,
                                short_options.c_str(), g_long_options, 0)) !=
         -1) {
    switch (ch) {
    case 0:
      break;

    case 'a':
      if (arch != NULL) {
        fprintf(stderr,
                "error: the --arch option can only be specified once\n");
        exit(1);
      }
      arch = optarg;
      break;

    case 'c':
      canonical = true;
      break;

    case 'x':
      external_only = true;
      break;

    case 'p':
      platform = optarg;
      break;

    case 'v':
      verbose = true;
      break;

    case 'h':
    case '?':
    default:
      show_usage = true;
      break;
    }
  }
  argc -= optind;
  argv += optind;

  const bool add_dependent_libs = false;
  SBError error;
  for (int arg_idx = 0; arg_idx < argc; ++arg_idx) {
    // The first argument is the file path we want to look something up in
    const char *exe_file_path = argv[arg_idx];

    // Create a target using the executable.
    SBTarget target = debugger.CreateTarget(exe_file_path, arch, platform,
                                            add_dependent_libs, error);

    if (error.Success()) {
      if (target.IsValid()) {
        SBFileSpec exe_file_spec(exe_file_path, true);
        SBModule module(target.FindModule(exe_file_spec));
        SBFileSpecList comp_unit_list;

        if (module.IsValid()) {
          char command[1024];
          lldb::SBCommandReturnObject command_result;
          snprintf(command, sizeof(command), "add-dsym --uuid %s",
                   module.GetUUIDString());
          debugger.GetCommandInterpreter().HandleCommand(command,
                                                         command_result);
          if (!command_result.Succeeded()) {
            fprintf(stderr, "error: couldn't locate debug symbols for '%s'\n",
                    exe_file_path);
            exit(1);
          }

          SBFileSpecList module_list;
          module_list.Append(exe_file_spec);
          SBBreakpoint bp =
              target.BreakpointCreateByRegex(".", module_list, comp_unit_list);

          const size_t num_locations = bp.GetNumLocations();
          for (uint32_t bp_loc_idx = 0; bp_loc_idx < num_locations;
               ++bp_loc_idx) {
            SBBreakpointLocation bp_loc = bp.GetLocationAtIndex(bp_loc_idx);
            SBSymbolContext sc(
                bp_loc.GetAddress().GetSymbolContext(eSymbolContextEverything));
            if (sc.IsValid()) {
              if (sc.GetBlock().GetContainingInlinedBlock().IsValid()) {
                // Skip inlined functions
                continue;
              }
              SBFunction function(sc.GetFunction());
              if (function.IsValid()) {
                addr_t lo_pc = function.GetStartAddress().GetFileAddress();
                if (lo_pc == LLDB_INVALID_ADDRESS) {
                  // Skip functions that don't have concrete instances in the
                  // binary
                  continue;
                }
                addr_t hi_pc = function.GetEndAddress().GetFileAddress();
                const char *func_demangled_name = function.GetName();
                const char *func_mangled_name = function.GetMangledName();

                bool dump = true;
                const bool is_objc_method = ((func_demangled_name[0] == '-') ||
                                             (func_demangled_name[0] == '+')) &&
                                            (func_demangled_name[1] == '[');
                if (external_only) {
                  // Dump all objective C methods, or external symbols
                  dump = is_objc_method;
                  if (!dump)
                    dump = sc.GetSymbol().IsExternal();
                }

                if (dump) {
                  if (verbose) {
                    printf("\n   name: %s\n", func_demangled_name);
                    if (func_mangled_name)
                      printf("mangled: %s\n", func_mangled_name);
                    printf("  range: [0x%16.16llx - 0x%16.16llx)\n   type: ",
                           lo_pc, hi_pc);
                  } else {
                    printf("[0x%16.16llx - 0x%16.16llx) ", lo_pc, hi_pc);
                  }
                  SBType function_type = function.GetType();
                  SBType return_type = function_type.GetFunctionReturnType();

                  if (canonical)
                    return_type = return_type.GetCanonicalType();

                  if (func_mangled_name && func_mangled_name[0] == '_' &&
                      func_mangled_name[1] == 'Z') {
                    printf("%s %s\n", return_type.GetName(),
                           func_demangled_name);
                  } else {
                    SBTypeList function_args =
                        function_type.GetFunctionArgumentTypes();
                    const size_t num_function_args = function_args.GetSize();

                    if (is_objc_method) {
                      const char *class_name_start = func_demangled_name + 2;

                      if (num_function_args == 0) {
                        printf("%c(%s)[%s\n", func_demangled_name[0],
                               return_type.GetName(), class_name_start);
                      } else {
                        const char *class_name_end =
                            strchr(class_name_start, ' ');
                        const int class_name_len =
                            class_name_end - class_name_start;
                        printf("%c(%s)[%*.*s", func_demangled_name[0],
                               return_type.GetName(), class_name_len,
                               class_name_len, class_name_start);

                        const char *selector_pos = class_name_end + 1;
                        for (uint32_t function_arg_idx = 0;
                             function_arg_idx < num_function_args;
                             ++function_arg_idx) {
                          const char *selector_end =
                              strchr(selector_pos, ':') + 1;
                          const int selector_len = selector_end - selector_pos;
                          SBType function_arg_type =
                              function_args.GetTypeAtIndex(function_arg_idx);

                          if (canonical)
                            function_arg_type =
                                function_arg_type.GetCanonicalType();

                          printf(" %*.*s", selector_len, selector_len,
                                 selector_pos);
                          if (function_arg_type.IsValid()) {
                            printf("(%s)", function_arg_type.GetName());
                          } else {
                            printf("(?)");
                          }
                          selector_pos = selector_end;
                        }
                        printf("]\n");
                      }
                    } else {
                      printf("%s ", return_type.GetName());
                      if (strchr(func_demangled_name, '('))
                        printf("(*)(");
                      else
                        printf("%s(", func_demangled_name);

                      for (uint32_t function_arg_idx = 0;
                           function_arg_idx < num_function_args;
                           ++function_arg_idx) {
                        SBType function_arg_type =
                            function_args.GetTypeAtIndex(function_arg_idx);

                        if (canonical)
                          function_arg_type =
                              function_arg_type.GetCanonicalType();

                        if (function_arg_type.IsValid()) {
                          printf("%s%s", function_arg_idx > 0 ? ", " : "",
                                 function_arg_type.GetName());
                        } else {
                          printf("%s???", function_arg_idx > 0 ? ", " : "");
                        }
                      }
                      printf(")\n");
                    }
                  }
                }
              }
            }
          }
        }
      }
    } else {
      fprintf(stderr, "error: %s\n", error.GetCString());
      exit(1);
    }
  }

  return 0;
}
