| //===-- 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; |
| } |
