+//===-- LLGDBMain.cpp -------------------------------------------*- C++ -*-===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#include <lldb/API/SBHostOS.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/PrettyStackTrace.h>
+#include <lldb/API/SBDebugger.h>
+#include <lldb/Utility/StreamString.h>
+#include <llvm/Support/Signals.h>
+#include <lldb/API/SBCommandInterpreter.h>
+#include <lldb/API/SBCommandReturnObject.h>
+#include <lldb/API/SBStringList.h>
+#include <boost/format.hpp>
+#include <readline/readline.h>
+#include <readline/history.h>
+#include <vector>
+#include <deque>
+#include <setjmp.h>
+#include <signal.h>
+#include <error.h>
+
+using namespace lldb;
+using namespace lldb_private;
+
+static jmp_buf llgdb_readline_jmp_buf;
+
+static void llgdb_readline_sigint_handler(int signum) {
+ assert(signum == SIGINT);
+ longjmp(llgdb_readline_jmp_buf, 1);
+}
+
+static char *llgdb_readline(const char *prompt) {
+ char *retval;
+ sighandler_t saved_handler;
+ sigset_t mask;
+ int i;
+
+ i = sigprocmask(SIG_SETMASK, NULL, &mask);
+ assert(i == 0);
+ saved_handler = signal(SIGINT, llgdb_readline_sigint_handler);
+ if (setjmp(llgdb_readline_jmp_buf) != 0) {
+ rl_free_line_state();
+ rl_cleanup_after_signal();
+
+ /* GDB prints this. */
+ puts("Quit");
+
+ i = sigprocmask(SIG_SETMASK, &mask, NULL);
+ assert(i == 0);
+ }
+ retval = readline(prompt);
+ saved_handler = signal(SIGINT, saved_handler);
+ assert(saved_handler == llgdb_readline_sigint_handler);
+ return retval;
+}
+
+#if 0
+static int console_cb_rows, console_cb_columns, console_cb_row,
+ console_cb_column;
+static bool console_cb_drop;
+
+static void console_cb(const char *str, void *data) {
+ const char *cs;
+
+ if (console_cb_drop)
+ return;
+ if (console_cb_rows == 0) {
+ fputs(str, stdout);
+ return;
+ }
+
+ while (*str != '\0') {
+ int columns;
+ size_t size;
+ char *answer;
+
+ cs = strchr(str, '\n');
+ if (cs == NULL)
+ cs = &str[strlen(str)];
+ columns = std::min(cs - str, long(console_cb_columns - console_cb_column));
+ if (columns > 0) {
+ size = fwrite(str, 1, columns, stdout);
+ assert(size == size_t(columns));
+ str += columns;
+ console_cb_column += columns;
+ continue;
+ }
+ if (*str == '\n')
+ str++;
+ else assert(console_cb_column < console_cb_columns);
+ putchar('\n');
+ console_cb_row++;
+ console_cb_column = 0;
+ if (console_cb_row < console_cb_rows - 1)
+ continue;
+ answer = llgdb_readline("---Type <return> to continue, or q <return> to quit---");
+ for (cs = answer; isspace(*cs); cs++)
+ ;
+ if (*cs == 'q') {
+ free(answer);
+ puts("Quit");
+ console_cb_drop = true;
+ return;
+ }
+ free(answer);
+ console_cb_row = 0;
+ }
+}
+#endif
+
+static void history_save(int rc, void *arg) {
+ const char *history_filename = static_cast<const char *>(arg);
+ write_history(history_filename);
+}
+
+static std::string settings_show_raw(SBDebugger &dbg, const char *setting, const char *type) {
+ SBCommandReturnObject Result;
+ dbg.GetCommandInterpreter().HandleCommand(("settings show " + std::string(setting)).c_str(), Result, /*add_to_history*/ false);
+ assert(Result.Succeeded());
+ // <plugin.process.gdb-remote.packet-timeout (unsigned) = 1\n
+ std::string str = Result.GetOutput();
+ const std::string expect = (boost::format("%1% (%2%) = ") % setting % type).str();
+ if (str.compare(0,expect.length(),expect)!=0||str[str.length()-1]!='\n')
+ error(1,0,"Unexpected 'settings show' response: expected=\"%s[...]\\n\" got=\"%s\"",expect.c_str(),str.c_str());
+ return str.substr(expect.length(),str.length()-1-expect.length());
+}
+
+#if 0
+static int settings_show_int(SBDebugger &dbg, const char *setting) {
+ std::string string = settings_show_raw(dbg, setting,"unsigned");
+ long l;
+ int retval;
+ char *end;
+
+ errno = 0;
+ retval = l = strtol(string.c_str(), &end, 10);
+ assert(errno == 0 && (end == NULL || *end == '\0') && retval == l);
+ return retval;
+}
+
+static bool settings_show_bool(SBDebugger &dbg, const char *setting) {
+ std::string string = settings_show_raw(dbg, setting,"unsigned");
+ bool retval;
+
+ retval = (string == "on");
+ assert(retval || string == "off");
+ return retval;
+}
+#endif
+
+static std::string settings_show_string(SBDebugger &dbg, const char *setting) {
+ std::string val = settings_show_raw(dbg,setting,"string");
+ if (val.length()<2 || val[0] != '"' || val[val.length()-1]!='"')
+ error(1,0,"Unexpected 'settings show' string response: expected '\"' quoting: %s", val.c_str());
+ return val.substr(1,val.length()-2);
+}
+
+static SBCommandReturnObject subcommand(SBDebugger &dbg, const char *cmd, bool print_command=true, bool add_to_history=false) {
+ if (print_command)
+ printf("%s%s\n",settings_show_string(dbg, "prompt").c_str(),cmd);
+ SBCommandReturnObject Result;
+ dbg.GetCommandInterpreter().HandleCommand(cmd, Result, add_to_history);
+ Result.PutOutput(stdout);
+ Result.PutError(stdout);
+ return Result;
+}
+
+static void default_command(SBDebugger &dbg, const char *cmd) {
+ subcommand(dbg, cmd, false/*print_command*/, true/*add_to_history*/);
+}
+
+static void quit_command(SBDebugger &dbg, const char *cmd) {
+ exit(EXIT_SUCCESS);
+}
+
+static void start_command(SBDebugger &dbg, const char *cmd) {
+ if (!subcommand(dbg, "b main").Succeeded())
+ return;
+ subcommand(dbg, ("run "+std::string(cmd)).c_str());
+}
+
+static void commands_command(SBDebugger &dbg, const char *cmd_param) {
+#if 0
+ char *cmd = xstrdup("");
+ size_t cmd_len = 0;
+ mi_output *res;
+ char *bpnum = NULL;
+ int nesting;
+
+ if (*cmd_param == '\0') {
+ mi_set_console_cb(h, commands_command_console_cb, &bpnum);
+ dbg.HandleCommand(h, "output $bpnum");
+ mi_set_console_cb(h, console_cb, NULL);
+ assert(bpnum != NULL);
+ cmd_param = bpnum;
+ }
+
+ printf(_("Type commands for breakpoint(s) %s, one per line.\n"
+ "End with a line saying just \"end\".\n"),
+ cmd_param);
+
+ nesting = 0;
+ while (nesting >= 0) {
+ char *prompt, *data, *data2, *start, *end;
+ size_t data2_len;
+ int do_nest = 0;
+
+ prompt = xstrprintf("%*s>", (int)nesting);
+ data = llgdb_readline(prompt);
+ free(prompt);
+ if (data == NULL)
+ data = xstrdup("end");
+
+ for (start = data; isspace(*start); start++)
+ ;
+ for (end = data + strlen(data); end > start && isspace(end[-1]); end--)
+ ;
+ data2 = malloc(end - start + 1);
+ memcpy(data2, start, end - start);
+ data2[end - start] = '\0';
+ if (strcmp(data2, "python") == 0)
+ do_nest = 1;
+ if (strcmp(data2, "end") == 0)
+ do_nest = -1;
+ for (end = data2; *end && !isspace(*end); end++)
+ ;
+ *end = '\0';
+
+ /* Here is a bug in GDB, it does not recognize command shortcuts. */
+ if (strcmp(data2, "while") == 0 || strcmp(data2, "if") == 0 ||
+ strcmp(data2, "commands") == 0 ||
+ strcmp(data2, "while-stepping") == 0 ||
+ strcmp(data2, "stepping") == 0 || strcmp(data2, "ws") == 0)
+ do_nest = 1;
+ free(data2);
+
+ nesting += do_nest;
+ if (nesting < 0)
+ break;
+
+ data2 = mi_escape(data);
+ free(data);
+ data2_len = strlen(data2);
+ cmd = xrealloc(cmd, cmd_len + 2 + data2_len + 2);
+ cmd[cmd_len] = ' ';
+ cmd[cmd_len + 1] = '"';
+ memcpy(&cmd[cmd_len + 2], data2, data2_len);
+ cmd[cmd_len + 2 + data2_len] = '"';
+ cmd[cmd_len + 2 + data2_len + 1] = '\0';
+ cmd_len += 2 + data2_len + 1;
+ free(data2);
+ }
+
+ mi_send(h, "-break-commands %s%s\n", cmd_param, cmd);
+ free(cmd);
+ free(bpnum);
+
+ res = mi_get_response_blk(h);
+ assert(res != NULL && res->next == NULL && res->tclass == MI_CL_DONE &&
+ res->c == NULL);
+ mi_free_output(res);
+#endif
+}
+
+struct Cmd {
+ const char *name;
+ int min_shortcut;
+ typedef void (func_t)(SBDebugger &dbg, const char *cmd);
+ func_t *func;
+ Cmd(const char *name_, int min_shortcut_, func_t *func_):name(name_),min_shortcut(min_shortcut_),func(func_) {}
+};
+const Cmd cmds[] = {
+ Cmd("quit", 1, quit_command),
+ Cmd("start", 5, start_command),
+ Cmd("commands", 4, commands_command),
+};
+
+static void executecommand(SBDebugger &dbg, const char *cmd_s) {
+ const char *start, *end, *cs;
+
+ cs = cmd_s;
+ while (isspace(*cs))
+ cs++;
+ start = cs;
+ while (isalnum(*cs))
+ cs++;
+ end = cs;
+ while (isspace(*cs))
+ cs++;
+
+ for (const Cmd &cmd : cmds)
+ if (cmd.min_shortcut <= end - start &&
+ size_t(end - start) <= strlen(cmd.name) &&
+ strncmp(start, cmd.name, end - start) == 0)
+ return cmd.func(dbg, cs);
+
+ return default_command(dbg, cmd_s);
+}
+
+static char *xstrdup(const char *cs) {
+ char *s = static_cast<char *>(malloc(strlen(cs)+1));
+ assert(s);
+ strcpy(s,cs);
+ return s;
+}
+
+static SBDebugger *completion_entry_function_dbgp;
+static char *completion_entry_function(const char *text, int matches) {
+ SBDebugger &dbg = *completion_entry_function_dbgp;
+ static std::vector<std::string> found_vec;
+ assert(matches >= 0);
+ if (matches == 0) {
+ found_vec.clear();
+ SBStringList matches;
+ // LLDB: FIXME: These two values are not implemented. m_match_start_point; m_max_return_elements;
+ const int match_start_point = 0;
+ // LLDB: Only max_return_elements == -1 is supported at present:
+ const int max_return_elements = -1;
+ int got=dbg.GetCommandInterpreter().HandleCompletion(text, strlen(text)/*cursor_pos*/, match_start_point, max_return_elements, matches);
+ assert(matches.IsValid());
+ if (unsigned(got+1)!=matches.GetSize())
+ error(1,0,"HandleCompletion=%d +1 != %u=matches.GetSize()",got,matches.GetSize());
+ //for (size_t ix=0;ix<matches.GetSize();++ix)
+ // fprintf(stderr,"match[%zu]=<%s>\n",ix,matches.GetStringAtIndex(ix));
+ const char *first=matches.GetStringAtIndex(0);
+ assert(matches.GetSize()>=1);
+ if (first[0]) {
+ std::string str(first);
+ while (!str.empty()&&str.back()==' ')
+ str.pop_back();
+ found_vec.push_back(text + str);
+ } else
+ for (size_t ix=1;ix<matches.GetSize();++ix)
+ found_vec.push_back(matches.GetStringAtIndex(ix));
+ }
+ if (size_t(matches) < found_vec.size())
+ return xstrdup(found_vec[matches].c_str());
+ else if (size_t(matches) == found_vec.size())
+ return nullptr;
+ else
+ assert(0);
+}
+
+static std::deque<std::string> opt_iex, opt_ex;
+static std::optional<std::string> opt_exec, opt_core;
+static std::vector<std::string> opt_args;
+
+std::string string_quote(std::string &&str) {
+ std::string retval = "\"";
+ for (const char c : str) {
+ if (c != '"')
+ retval.push_back(c);
+ else
+ retval += "\\\"";
+ }
+ return retval + "\"";
+}
+
+std::optional<std::string> next_arg() {
+ if (!opt_iex.empty()) {
+ std::string retval = opt_iex.front();
+ opt_iex.pop_front();
+ return retval;
+ }
+ if (opt_exec || opt_core) {
+ std::string cmd = "target create";
+ if (opt_exec) {
+ cmd += " " + string_quote(std::move(*opt_exec));
+ opt_exec.reset();
+ }
+ if (opt_core) {
+ cmd += " --core " + string_quote(std::move(*opt_core));
+ opt_core.reset();
+ }
+ return cmd;
+ }
+ if (!opt_ex.empty()) {
+ std::string retval = opt_ex.front();
+ opt_ex.pop_front();
+ return retval;
+ }
+ return {};
+}
+
+int main(int argc, char **argv) {
+ llvm::StringRef ToolName = argv[0];
+ llvm::sys::PrintStackTraceOnErrorSignal(ToolName);
+ llvm::PrettyStackTraceProgram X(argc, argv);
+
+ for (int argi = 1; argi < argc; ++argi) {
+ std::string arg = argv[argi];
+ if (arg == "-iex") {
+ const char *cmd = argv[++argi];
+ assert(cmd);
+ opt_iex.push_back(cmd);
+ } else if (arg == "-ex") {
+ const char *cmd = argv[++argi];
+ assert(cmd);
+ opt_ex.push_back(cmd);
+ } else if (arg == "--args") {
+ const char *exec = argv[++argi];
+ assert(exec);
+ assert(!opt_exec);
+ assert(!opt_core);
+ assert(opt_args.empty());
+ opt_exec=std::string(exec);
+ while (++argi<argc) {
+ arg = argv[argi];
+ opt_args.push_back(std::move(arg));
+ }
+ } else if (!opt_exec)
+ opt_exec=std::move(arg);
+ else if (!opt_core)
+ opt_core=std::move(arg);
+ else
+ error(1,0,"Excessive argument: %s",arg.c_str());
+ }
+
+ SBDebugger::Initialize();
+ SBDebugger dbg = SBDebugger::Create();
+ dbg.HandleCommand("settings set symbols.enable-external-lookup false");
+
+ completion_entry_function_dbgp=&dbg;
+ rl_completion_entry_function = completion_entry_function;
+ rl_readline_name = "llgdb";
+
+ if (true/*settings_show_bool(dbg, "history save")*/) {
+ int history_size = 1000000; //settings_show_int(dbg, "history size");
+ const char *HOME = getenv("HOME");
+ assert(HOME);
+ static const std::string history_filename = std::string(HOME) + "/.llgdb_history"; // settings_show_string(dbg, "history filename");
+ //gdb_set_bool(dbg, "history save", false);
+ stifle_history(history_size);
+ read_history(history_filename.c_str());
+ on_exit(history_save, static_cast<void *>(const_cast<char *>(history_filename.c_str())));
+ /* Do not free HISTORY_FILENAME. */
+ }
+
+ for (;;) {
+
+ std::string prompt = settings_show_string(dbg, "prompt");
+ std::optional<std::string> arg = next_arg();
+ std::string cmd;
+ if (!arg) {
+ char *cmd_s = llgdb_readline(prompt.c_str());
+ if (cmd_s)
+ add_history(cmd_s);
+ cmd = cmd_s?:"quit";
+ free(cmd_s);
+ } else {
+ puts((prompt + *arg).c_str());
+ cmd = std::move(*arg);
+ }
+
+#if 0
+ /* FIXME: -ex commands do not have pagination set. */
+ if (false /*!settings_show_bool(h, "pagination")*/)
+ console_cb_rows = 0;
+ else
+ rl_get_screen_size(&console_cb_rows, &console_cb_columns);
+ console_cb_drop = false;
+ console_cb_row = console_cb_column = 0;
+#endif
+
+ executecommand(dbg, cmd.c_str());
+ }
+}
git://git.jankratochvil.net / llgdb.git / commitdiff