lldb/examples/functions/main.cpp

   1 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <getopt.h>
  10 #include <stdint.h>
  11 #include <stdlib.h>
  12
  13 #if defined(__APPLE__)
  14 #include <LLDB/LLDB.h>
  15 #else
  16 #include "LLDB/SBBlock.h"
  17 #include "LLDB/SBCompileUnit.h"
  18 #include "LLDB/SBDebugger.h"
  19 #include "LLDB/SBFunction.h"
  20 #include "LLDB/SBModule.h"
  21 #include "LLDB/SBProcess.h"
  22 #include "LLDB/SBStream.h"
  23 #include "LLDB/SBSymbol.h"
  24 #include "LLDB/SBTarget.h"
  25 #include "LLDB/SBThread.h"
  26 #endif
  27
  28 #include <string>
  29
  30 using namespace lldb;
  31
  32 // This quick sample code shows how to create a debugger instance and
  33 // create an executable target without adding dependent shared
  34 // libraries. It will then set a regular expression breakpoint to get
  35 // breakpoint locations for all functions in the module, and use the
  36 // locations to extract the symbol context for each location. Then it
  37 // dumps all // information about the function: its name, file address
  38 // range, the return type (if any), and all argument types.
  39 //
  40 // To build the program, type (while in this directory):
  41 //
  42 //    $ make
  43 //
  44 // then to run this on MacOSX, specify the path to your LLDB.framework
  45 // library using the DYLD_FRAMEWORK_PATH option and run the executable
  46 //
  47 //    $ DYLD_FRAMEWORK_PATH=/Volumes/data/lldb/tot/build/Debug ./a.out
  48 //    executable_path1 [executable_path2 ...]
  49 class LLDBSentry {
  50 public:
  51   LLDBSentry() {
  52     // Initialize LLDB
  53     SBDebugger::Initialize();
  54   }
  55   ~LLDBSentry() {
  56     // Terminate LLDB
  57     SBDebugger::Terminate();
  58   }
  59 };
  60
  61 static struct option g_long_options[] = {
  62     {"arch", required_argument, NULL, 'a'},
  63     {"canonical", no_argument, NULL, 'c'},
  64     {"extern", no_argument, NULL, 'x'},
  65     {"help", no_argument, NULL, 'h'},
  66     {"platform", required_argument, NULL, 'p'},
  67     {"verbose", no_argument, NULL, 'v'},
  68     {NULL, 0, NULL, 0}};
  69
  70 #define PROGRAM_NAME "lldb-functions"
  71 void usage() {
  72   puts("NAME\n"
  73        "    " PROGRAM_NAME
  74        " -- extract all function signatures from one or more binaries.\n"
  75        "\n"
  76        "SYNOPSIS\n"
  77        "    " PROGRAM_NAME " [[--arch=<ARCH>] [--platform=<PLATFORM>] "
  78                            "[--verbose] [--help] [--canonical] --] <PATH> "
  79                            "[<PATH>....]\n"
  80        "\n"
  81        "DESCRIPTION\n"
  82        "    Loads the executable pointed to by <PATH> and dumps complete "
  83        "signatures for all functions that have debug information.\n"
  84        "\n"
  85        "EXAMPLE\n"
  86        "   " PROGRAM_NAME " --arch=x86_64 /usr/lib/dyld\n");
  87   exit(0);
  88 }
  89 int main(int argc, char const *argv[]) {
  90   // Use a sentry object to properly initialize/terminate LLDB.
  91   LLDBSentry sentry;
  92
  93   SBDebugger debugger(SBDebugger::Create());
  94
  95   // Create a debugger instance so we can create a target
  96   if (!debugger.IsValid())
  97     fprintf(stderr, "error: failed to create a debugger object\n");
  98
  99   bool show_usage = false;
 100   bool verbose = false;
 101   bool canonical = false;
 102   bool external_only = false;
 103   const char *arch = NULL;
 104   const char *platform = NULL;
 105   std::string short_options("h?");
 106   for (const struct option *opt = g_long_options; opt->name; ++opt) {
 107     if (isprint(opt->val)) {
 108       short_options.append(1, (char)opt->val);
 109       switch (opt->has_arg) {
 110       case no_argument:
 111         break;
 112       case required_argument:
 113         short_options.append(1, ':');
 114         break;
 115       case optional_argument:
 116         short_options.append(2, ':');
 117         break;
 118       }
 119     }
 120   }
 121 #ifdef __GLIBC__
 122   optind = 0;
 123 #else
 124   optreset = 1;
 125   optind = 1;
 126 #endif
 127   char ch;
 128   while ((ch = getopt_long_only(argc, (char *const *)argv,
 129                                 short_options.c_str(), g_long_options, 0)) !=
 130          -1) {
 131     switch (ch) {
 132     case 0:
 133       break;
 134
 135     case 'a':
 136       if (arch != NULL) {
 137         fprintf(stderr,
 138                 "error: the --arch option can only be specified once\n");
 139         exit(1);
 140       }
 141       arch = optarg;
 142       break;
 143
 144     case 'c':
 145       canonical = true;
 146       break;
 147
 148     case 'x':
 149       external_only = true;
 150       break;
 151
 152     case 'p':
 153       platform = optarg;
 154       break;
 155
 156     case 'v':
 157       verbose = true;
 158       break;
 159
 160     case 'h':
 161     case '?':
 162     default:
 163       show_usage = true;
 164       break;
 165     }
 166   }
 167   argc -= optind;
 168   argv += optind;
 169
 170   const bool add_dependent_libs = false;
 171   SBError error;
 172   for (int arg_idx = 0; arg_idx < argc; ++arg_idx) {
 173     // The first argument is the file path we want to look something up in
 174     const char *exe_file_path = argv[arg_idx];
 175
 176     // Create a target using the executable.
 177     SBTarget target = debugger.CreateTarget(exe_file_path, arch, platform,
 178                                             add_dependent_libs, error);
 179
 180     if (error.Success()) {
 181       if (target.IsValid()) {
 182         SBFileSpec exe_file_spec(exe_file_path, true);
 183         SBModule module(target.FindModule(exe_file_spec));
 184         SBFileSpecList comp_unit_list;
 185
 186         if (module.IsValid()) {
 187           char command[1024];
 188           lldb::SBCommandReturnObject command_result;
 189           snprintf(command, sizeof(command), "add-dsym --uuid %s",
 190                    module.GetUUIDString());
 191           debugger.GetCommandInterpreter().HandleCommand(command,
 192                                                          command_result);
 193           if (!command_result.Succeeded()) {
 194             fprintf(stderr, "error: couldn't locate debug symbols for '%s'\n",
 195                     exe_file_path);
 196             exit(1);
 197           }
 198
 199           SBFileSpecList module_list;
 200           module_list.Append(exe_file_spec);
 201           SBBreakpoint bp =
 202               target.BreakpointCreateByRegex(".", module_list, comp_unit_list);
 203
 204           const size_t num_locations = bp.GetNumLocations();
 205           for (uint32_t bp_loc_idx = 0; bp_loc_idx < num_locations;
 206                ++bp_loc_idx) {
 207             SBBreakpointLocation bp_loc = bp.GetLocationAtIndex(bp_loc_idx);
 208             SBSymbolContext sc(
 209                 bp_loc.GetAddress().GetSymbolContext(eSymbolContextEverything));
 210             if (sc.IsValid()) {
 211               if (sc.GetBlock().GetContainingInlinedBlock().IsValid()) {
 212                 // Skip inlined functions
 213                 continue;
 214               }
 215               SBFunction function(sc.GetFunction());
 216               if (function.IsValid()) {
 217                 addr_t lo_pc = function.GetStartAddress().GetFileAddress();
 218                 if (lo_pc == LLDB_INVALID_ADDRESS) {
 219                   // Skip functions that don't have concrete instances in the
 220                   // binary
 221                   continue;
 222                 }
 223                 addr_t hi_pc = function.GetEndAddress().GetFileAddress();
 224                 const char *func_demangled_name = function.GetName();
 225                 const char *func_mangled_name = function.GetMangledName();
 226
 227                 bool dump = true;
 228                 const bool is_objc_method = ((func_demangled_name[0] == '-') ||
 229                                              (func_demangled_name[0] == '+')) &&
 230                                             (func_demangled_name[1] == '[');
 231                 if (external_only) {
 232                   // Dump all objective C methods, or external symbols
 233                   dump = is_objc_method;
 234                   if (!dump)
 235                     dump = sc.GetSymbol().IsExternal();
 236                 }
 237
 238                 if (dump) {
 239                   if (verbose) {
 240                     printf("\n   name: %s\n", func_demangled_name);
 241                     if (func_mangled_name)
 242                       printf("mangled: %s\n", func_mangled_name);
 243                     printf("  range: [0x%16.16llx - 0x%16.16llx)\n   type: ",
 244                            lo_pc, hi_pc);
 245                   } else {
 246                     printf("[0x%16.16llx - 0x%16.16llx) ", lo_pc, hi_pc);
 247                   }
 248                   SBType function_type = function.GetType();
 249                   SBType return_type = function_type.GetFunctionReturnType();
 250
 251                   if (canonical)
 252                     return_type = return_type.GetCanonicalType();
 253
 254                   if (func_mangled_name && func_mangled_name[0] == '_' &&
 255                       func_mangled_name[1] == 'Z') {
 256                     printf("%s %s\n", return_type.GetName(),
 257                            func_demangled_name);
 258                   } else {
 259                     SBTypeList function_args =
 260                         function_type.GetFunctionArgumentTypes();
 261                     const size_t num_function_args = function_args.GetSize();
 262
 263                     if (is_objc_method) {
 264                       const char *class_name_start = func_demangled_name + 2;
 265
 266                       if (num_function_args == 0) {
 267                         printf("%c(%s)[%s\n", func_demangled_name[0],
 268                                return_type.GetName(), class_name_start);
 269                       } else {
 270                         const char *class_name_end =
 271                             strchr(class_name_start, ' ');
 272                         const int class_name_len =
 273                             class_name_end - class_name_start;
 274                         printf("%c(%s)[%*.*s", func_demangled_name[0],
 275                                return_type.GetName(), class_name_len,
 276                                class_name_len, class_name_start);
 277
 278                         const char *selector_pos = class_name_end + 1;
 279                         for (uint32_t function_arg_idx = 0;
 280                              function_arg_idx < num_function_args;
 281                              ++function_arg_idx) {
 282                           const char *selector_end =
 283                               strchr(selector_pos, ':') + 1;
 284                           const int selector_len = selector_end - selector_pos;
 285                           SBType function_arg_type =
 286                               function_args.GetTypeAtIndex(function_arg_idx);
 287
 288                           if (canonical)
 289                             function_arg_type =
 290                                 function_arg_type.GetCanonicalType();
 291
 292                           printf(" %*.*s", selector_len, selector_len,
 293                                  selector_pos);
 294                           if (function_arg_type.IsValid()) {
 295                             printf("(%s)", function_arg_type.GetName());
 296                           } else {
 297                             printf("(?)");
 298                           }
 299                           selector_pos = selector_end;
 300                         }
 301                         printf("]\n");
 302                       }
 303                     } else {
 304                       printf("%s ", return_type.GetName());
 305                       if (strchr(func_demangled_name, '('))
 306                         printf("(*)(");
 307                       else
 308                         printf("%s(", func_demangled_name);
 309
 310                       for (uint32_t function_arg_idx = 0;
 311                            function_arg_idx < num_function_args;
 312                            ++function_arg_idx) {
 313                         SBType function_arg_type =
 314                             function_args.GetTypeAtIndex(function_arg_idx);
 315
 316                         if (canonical)
 317                           function_arg_type =
 318                               function_arg_type.GetCanonicalType();
 319
 320                         if (function_arg_type.IsValid()) {
 321                           printf("%s%s", function_arg_idx > 0 ? ", " : "",
 322                                  function_arg_type.GetName());
 323                         } else {
 324                           printf("%s???", function_arg_idx > 0 ? ", " : "");
 325                         }
 326                       }
 327                       printf(")\n");
 328                     }
 329                   }
 330                 }
 331               }
 332             }
 333           }
 334         }
 335       }
 336     } else {
 337       fprintf(stderr, "error: %s\n", error.GetCString());
 338       exit(1);
 339     }
 340   }
 341
 342   return 0;
 343 }