Initial checkin of the LLVM Source-Level Debugger. This is incomplete, but
a good start. The status is documented in docs/SourceLevelDebugging.html
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10687 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/tools/llvm-db/CLIDebugger.h b/tools/llvm-db/CLIDebugger.h
new file mode 100644
index 0000000..046c2e8
--- /dev/null
+++ b/tools/llvm-db/CLIDebugger.h
@@ -0,0 +1,200 @@
+//===- CLIDebugger.h - LLVM Command Line Interface Debugger -----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the CLIDebugger class, which implements a command line
+// interface to the LLVM Debugger library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CLIDEBUGGER_H
+#define CLIDEBUGGER_H
+
+#include "llvm/Debugger/Debugger.h"
+#include <map>
+
+namespace llvm {
+ class CLICommand;
+ class SourceFile;
+ class SourceLanguage;
+ class ProgramInfo;
+ class RuntimeInfo;
+
+ /// CLIDebugger - This class implements the command line interface for the
+ /// LLVM debugger.
+ class CLIDebugger {
+ /// Dbg - The low-level LLVM debugger object that we use to do our dirty
+ /// work.
+ Debugger Dbg;
+
+ /// CommandTable - This table contains a mapping from command names to the
+ /// CLICommand object that implements the command.
+ std::map<std::string, CLICommand*> CommandTable;
+
+ //===------------------------------------------------------------------===//
+ // Data related to the program that is currently loaded. Note that the Dbg
+ // variable also captures some information about the loaded program. This
+ // pointer is non-null iff Dbg.isProgramLoaded() is true.
+ //
+ ProgramInfo *TheProgramInfo;
+
+ //===------------------------------------------------------------------===//
+ // Data related to the program that is currently executing, but has stopped.
+ // Note that the Dbg variable also captures some information about the
+ // loaded program. This pointer is non-null iff Dbg.isProgramRunning() is
+ // true.
+ //
+ RuntimeInfo *TheRuntimeInfo;
+
+ /// LastCurrentFrame - This variable holds the Frame ID of the top-level
+ /// stack frame from the last time that the program was executed. We keep
+ /// this because we only want to print the source location when the current
+ /// function changes.
+ void *LastCurrentFrame;
+
+ //===------------------------------------------------------------------===//
+ // Data directly exposed through the debugger prompt
+ //
+ std::string Prompt; // set prompt, show prompt
+ unsigned ListSize; // set listsize, show listsize
+
+ //===------------------------------------------------------------------===//
+ // Data to support user interaction
+ //
+
+ /// CurrentFile - The current source file we are inspecting, or null if
+ /// none.
+ const SourceFile *CurrentFile;
+ unsigned LineListedStart, LineListedEnd;
+
+ /// CurrentLanguage - This contains the source language in use, if one is
+ /// explicitly set by the user. If this is null (the default), the language
+ /// is automatically determined from the current stack frame.
+ ///
+ const SourceLanguage *CurrentLanguage;
+
+ public:
+ CLIDebugger();
+
+ /// getDebugger - Return the current LLVM debugger implementation being
+ /// used.
+ Debugger &getDebugger() { return Dbg; }
+
+ /// run - Start the debugger, returning when the user exits the debugger.
+ /// This starts the main event loop of the CLI debugger.
+ ///
+ int run();
+
+ /// addCommand - Add a command to the CommandTable, potentially displacing a
+ /// preexisting command.
+ void addCommand(const std::string &Option, CLICommand *Cmd);
+
+ /// addSourceDirectory - Add a directory to search when looking for the
+ /// source code of the program.
+ void addSourceDirectory(const std::string &Dir) {
+ // FIXME: implement
+ }
+
+ /// getCurrentLanguage - Return the current source language that the user is
+ /// playing around with. This is aquired from the current stack frame of a
+ /// running program if one exists, but this value can be explicitly set by
+ /// the user as well.
+ const SourceLanguage &getCurrentLanguage() const;
+
+ /// getProgramInfo - Return a reference to the ProgramInfo object for the
+ /// currently loaded program. If there is no program loaded, throw an
+ /// exception.
+ ProgramInfo &getProgramInfo() const {
+ if (TheProgramInfo == 0)
+ throw "No program is loaded.";
+ return *TheProgramInfo;
+ }
+
+ /// getRuntimeInfo - Return a reference to the current RuntimeInfo object.
+ /// If there is no program running, throw an exception.
+ RuntimeInfo &getRuntimeInfo() const {
+ if (TheRuntimeInfo == 0)
+ throw "No program is running.";
+ return *TheRuntimeInfo;
+ }
+
+ private: // Internal implementation methods
+
+ /// getCommand - This looks up the specified command using a fuzzy match.
+ /// If the string exactly matches a command or is an unambiguous prefix of a
+ /// command, it returns the command. Otherwise it throws an exception
+ /// indicating the possible ambiguous choices.
+ CLICommand *getCommand(const std::string &Command);
+
+ /// askYesNo - Ask the user a question, and demand a yes/no response. If
+ /// the user says yes, return true.
+ bool askYesNo(const std::string &Message) const;
+
+ /// printProgramLocation - Given a loaded and created child process that has
+ /// stopped, print its current source location.
+ void printProgramLocation(bool PrintLocation = true);
+
+ /// eliminateRunInfo - We are about to run the program. Forget any state
+ /// about how the program used to be stopped.
+ void eliminateRunInfo();
+
+ /// programStoppedSuccessfully - This method updates internal data
+ /// structures to reflect the fact that the program just executed a while,
+ /// and has successfully stopped.
+ void programStoppedSuccessfully();
+
+ public: /// Builtin debugger commands, invokable by the user
+ // Program startup and shutdown options
+ void fileCommand(std::string &Options); // file
+ void createCommand(std::string &Options); // create
+ void killCommand(std::string &Options); // kill
+ void quitCommand(std::string &Options); // quit
+
+ // Program execution commands
+ void runCommand(std::string &Options); // run|r
+ void contCommand(std::string &Options); // cont|c|fg
+ void stepCommand(std::string &Options); // step|s [count]
+ void nextCommand(std::string &Options); // next|n [count]
+ void finishCommand(std::string &Options); // finish
+
+ // Stack frame commands
+ void backtraceCommand(std::string &Options); // backtrace|bt [count]
+ void upCommand(std::string &Options); // up
+ void downCommand(std::string &Options); // down
+ void frameCommand(std::string &Options); // frame
+
+
+ // Breakpoint related commands
+ void breakCommand(std::string &Options); // break|b <id>
+
+ // Miscellaneous commands
+ void infoCommand(std::string &Options); // info
+ void listCommand(std::string &Options); // list
+ void setCommand(std::string &Options); // set
+ void showCommand(std::string &Options); // show
+ void helpCommand(std::string &Options); // help
+
+ private:
+ /// startProgramRunning - If the program has been updated, reload it, then
+ /// start executing the program.
+ void startProgramRunning();
+
+ /// parseLineSpec - Parses a line specifier, for use by the 'list' command.
+ /// If SourceFile is returned as a void pointer, then it was not specified.
+ /// If the line specifier is invalid, an exception is thrown.
+ void parseLineSpec(std::string &LineSpec, const SourceFile *&SourceFile,
+ unsigned &LineNo);
+
+ /// printSourceLine - Print the specified line of the current source file.
+ /// If the specified line is invalid (the source file could not be loaded or
+ /// the line number is out of range), don't print anything, but return true.
+ bool printSourceLine(unsigned LineNo);
+ };
+}
+
+#endif