diff options
Diffstat (limited to 'llvm/tools')
| -rw-r--r-- | llvm/tools/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | llvm/tools/Makefile | 2 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/CLICommand.h | 111 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/CLIDebugger.cpp | 309 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/CLIDebugger.h | 208 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/CMakeLists.txt | 8 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/Commands.cpp | 866 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/Makefile | 15 | ||||
| -rw-r--r-- | llvm/tools/llvm-db/llvm-db.cpp | 102 |
9 files changed, 1 insertions, 1621 deletions
diff --git a/llvm/tools/CMakeLists.txt b/llvm/tools/CMakeLists.txt index a253b33ecc8..8b5d77e2c42 100644 --- a/llvm/tools/CMakeLists.txt +++ b/llvm/tools/CMakeLists.txt @@ -27,7 +27,6 @@ add_subdirectory(llvm-link) add_subdirectory(lli) add_subdirectory(llvm-extract) -add_subdirectory(llvm-db) add_subdirectory(bugpoint) add_subdirectory(llvm-bcanalyzer) diff --git a/llvm/tools/Makefile b/llvm/tools/Makefile index caf8b2f22bf..0340c7f78bb 100644 --- a/llvm/tools/Makefile +++ b/llvm/tools/Makefile @@ -19,7 +19,7 @@ DIRS := llvm-config PARALLEL_DIRS := opt llvm-as llvm-dis \ llc llvm-ranlib llvm-ar llvm-nm \ llvm-ld llvm-prof llvm-link \ - lli llvm-extract llvm-db \ + lli llvm-extract \ bugpoint llvm-bcanalyzer llvm-stub \ llvm-mc llvmc diff --git a/llvm/tools/llvm-db/CLICommand.h b/llvm/tools/llvm-db/CLICommand.h deleted file mode 100644 index 0beec91eda0..00000000000 --- a/llvm/tools/llvm-db/CLICommand.h +++ /dev/null @@ -1,111 +0,0 @@ -//===- CLICommand.h - Classes used to represent commands --------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines a small class hierarchy used to represent the various types -// of commands in the CLI debugger front-end. -// -//===----------------------------------------------------------------------===// - -#ifndef CLICOMMAND_H -#define CLICOMMAND_H - -#include <string> -#include <vector> -#include <cassert> - -namespace llvm { - class CLIDebugger; - - /// CLICommand - Base class of the hierarchy, used to provide the abstract - /// interface common to all commands. - /// - class CLICommand { - /// ShortHelp, LongHelp - The short and long helps strings printed for the - /// command. The ShortHelp string should be a single line of text without a - /// newline. The LongHelp string should be a full description with - /// terminating newline. - std::string ShortHelp, LongHelp; - - /// RefCount - This contains the number of entries in the CLIDebugger - /// CommandTable that points to this command. - unsigned RefCount; - - /// OptionNames - This contains a list of names for the option. Keeping - /// track of this is done just to make the help output more helpful. - /// - std::vector<std::string> OptionNames; - public: - CLICommand(const std::string &SH, const std::string &LH) - : ShortHelp(SH), LongHelp(LH), RefCount(0) {} - - virtual ~CLICommand() {} - - /// addRef/dropRef - Implement a simple reference counting scheme to make - /// sure we delete commands that are no longer used. - void addRef() { ++RefCount; } - void dropRef() { - if (--RefCount == 0) delete this; - } - - /// getPrimaryOptionName - Return the first name the option was added under. - /// This is the name we report for the option in the help output. - std::string getPrimaryOptionName() const { - return OptionNames.empty() ? "" : OptionNames[0]; - } - - /// getOptionName - Return all of the names the option is registered as. - /// - const std::vector<std::string> &getOptionNames() const { - return OptionNames; - } - - /// addOptionName - Add a name that this option is known as. - /// - void addOptionName(const std::string &Name) { - OptionNames.push_back(Name); - } - - /// removeOptionName - Eliminate one of the names for this option. - /// - void removeOptionName(const std::string &Name) { - unsigned i = 0; - for (; OptionNames[i] != Name; ++i) - assert(i+1 < OptionNames.size() && "Didn't find option name!"); - OptionNames.erase(OptionNames.begin()+i); - } - - - /// getShortHelp - Return the short help string for this command. - /// - const std::string &getShortHelp() { return ShortHelp; } - - /// getLongHelp - Return the long help string for this command, if it - /// exists. - const std::string &getLongHelp() { return LongHelp; } - - virtual void runCommand(CLIDebugger &D, std::string &Arguments) = 0; - }; - - /// BuiltinCLICommand - This class represents commands that are built directly - /// into the debugger. - class BuiltinCLICommand : public CLICommand { - // Impl - Pointer to the method that implements the command - void (CLIDebugger::*Impl)(std::string&); - public: - BuiltinCLICommand(const std::string &ShortHelp, const std::string &LongHelp, - void (CLIDebugger::*impl)(std::string&)) - : CLICommand(ShortHelp, LongHelp), Impl(impl) {} - - void runCommand(CLIDebugger &D, std::string &Arguments) { - (D.*Impl)(Arguments); - } - }; -} - -#endif diff --git a/llvm/tools/llvm-db/CLIDebugger.cpp b/llvm/tools/llvm-db/CLIDebugger.cpp deleted file mode 100644 index 31476f7d0b7..00000000000 --- a/llvm/tools/llvm-db/CLIDebugger.cpp +++ /dev/null @@ -1,309 +0,0 @@ -//===-- CLIDebugger.cpp - Command Line Interface to the Debugger ----------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the main implementation of the Command Line Interface to -// the debugger. -// -//===----------------------------------------------------------------------===// - -#include "CLIDebugger.h" -#include "CLICommand.h" -#include "llvm/Debugger/SourceFile.h" -#include "llvm/ADT/StringExtras.h" -#include <iostream> -using namespace llvm; - -/// CLIDebugger constructor - This initializes the debugger to its default -/// state, and initializes the command table. -/// -CLIDebugger::CLIDebugger(LLVMContext& ctxt) - : Context(ctxt), TheProgramInfo(0), TheRuntimeInfo(0), - Prompt("(llvm-db) "), ListSize(10) { - // Initialize instance variables - CurrentFile = 0; - LineListedStart = 1; - LineListedEnd = 1; - LastCurrentFrame = 0; - CurrentLanguage = 0; - - CLICommand *C; - //===--------------------------------------------------------------------===// - // Program startup and shutdown options - // - addCommand("file", new BuiltinCLICommand( - "Use specified file as the program to be debugged", - "The debugger looks in the current directory and the program $PATH for the" - " specified LLVM program. It then unloads the currently loaded program and" - " loads the specified program.\n", - &CLIDebugger::fileCommand)); - - addCommand("create", new BuiltinCLICommand( - "Start the program, halting its execution in main", - "This command creates an instance of the current program, but stops" - "\nexecution immediately.\n", - &CLIDebugger::createCommand)); - - addCommand("kill", new BuiltinCLICommand( - "Kills the execution of the current program being debugged", "", - &CLIDebugger::killCommand)); - - addCommand("quit", new BuiltinCLICommand( - "Exit the debugger", "", - &CLIDebugger::quitCommand)); - - //===--------------------------------------------------------------------===// - // Program execution commands - // - addCommand("run", C = new BuiltinCLICommand( - "Start the program running from the beginning", "", - &CLIDebugger::runCommand)); - addCommand("r", C); - - addCommand("cont", C = new BuiltinCLICommand( - "Continue program being debugged until the next stop point", "", - &CLIDebugger::contCommand)); - addCommand("c", C); addCommand("fg", C); - - addCommand("step", C = new BuiltinCLICommand( - "Step program until it reaches a new source line", "", - &CLIDebugger::stepCommand)); - addCommand("s", C); - - addCommand("next", C = new BuiltinCLICommand( - "Step program until it reaches a new source line, stepping over calls", "", - &CLIDebugger::nextCommand)); - addCommand("n", C); - - addCommand("finish", new BuiltinCLICommand( - "Execute until the selected stack frame returns", - "Upon return, the value returned is printed and put in the value history.\n", - &CLIDebugger::finishCommand)); - - //===--------------------------------------------------------------------===// - // Stack frame commands - // - addCommand("backtrace", C = new BuiltinCLICommand( - "Print backtrace of all stack frames, or innermost COUNT frames", - "FIXME: describe. Takes 'n', '-n' or 'full'\n", - &CLIDebugger::backtraceCommand)); - addCommand("bt", C); - - addCommand("up", new BuiltinCLICommand( - "Select and print stack frame that called this one", - "An argument says how many frames up to go.\n", - &CLIDebugger::upCommand)); - - addCommand("down", new BuiltinCLICommand( - "Select and print stack frame called by this one", - "An argument says how many frames down go.\n", - &CLIDebugger::downCommand)); - - addCommand("frame", C = new BuiltinCLICommand( - "Select and print a stack frame", - "With no argument, print the selected stack frame. (See also 'info frame').\n" - "An argument specifies the frame to select.\n", - &CLIDebugger::frameCommand)); - addCommand("f", C); - - //===--------------------------------------------------------------------===// - // Breakpoint related commands - // - addCommand("break", C = new BuiltinCLICommand( - "Set breakpoint at specified line or function", - "FIXME: describe.\n", - &CLIDebugger::breakCommand)); - addCommand("b", C); - - - //===--------------------------------------------------------------------===// - // Miscellaneous commands - // - addCommand("info", new BuiltinCLICommand( - "Generic command for showing things about the program being debugged", - "info functions: display information about functions in the program.\ninfo" - " source : display information about the current source file.\ninfo source" - "s : Display source file names for the program\ninfo target : print status" - " of inferior process\n", - &CLIDebugger::infoCommand)); - - addCommand("list", C = new BuiltinCLICommand( - "List specified function or line", - "FIXME: document\n", - &CLIDebugger::listCommand)); - addCommand("l", C); - - addCommand("set", new BuiltinCLICommand( - "Change program or debugger variable", - "FIXME: document\n", - &CLIDebugger::setCommand)); - - addCommand("show", new BuiltinCLICommand( - "Generic command for showing things about the debugger", - "FIXME: document\n", - &CLIDebugger::showCommand)); - - addCommand("help", C = new BuiltinCLICommand( - "Prints information about available commands", "", - &CLIDebugger::helpCommand)); - addCommand("h", C); -} - - -/// addCommand - Add a command to the CommandTable, potentially displacing a -/// preexisting command. -void CLIDebugger::addCommand(const std::string &Option, CLICommand *Cmd) { - assert(Cmd && "Cannot set a null command!"); - CLICommand *&CS = CommandTable[Option]; - if (CS == Cmd) return; // noop - - // If we already have a command, decrement the command's reference count. - if (CS) { - CS->removeOptionName(Option); - CS->dropRef(); - } - CS = Cmd; - - // Remember that we are using this command. - Cmd->addRef(); - Cmd->addOptionName(Option); -} - -static bool isValidPrefix(const std::string &Prefix, const std::string &Option){ - return Prefix.size() <= Option.size() && - Prefix == std::string(Option.begin(), Option.begin()+Prefix.size()); -} - -/// 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 *CLIDebugger::getCommand(const std::string &Command) { - - // Look up the command in the table. - std::map<std::string, CLICommand*>::iterator CI = - CommandTable.lower_bound(Command); - - if (Command == "") { - throw "Null command should not get here!"; - } else if (CI == CommandTable.end() || - !isValidPrefix(Command, CI->first)) { - // If this command has no relation to anything in the command table, - // print the error message. - throw "Unknown command: '" + Command + - "'. Use 'help' for list of commands."; - } else if (CI->first == Command) { - // We have an exact match on the command - return CI->second; - } else { - // Otherwise, we have a prefix match. Check to see if this is - // unambiguous, and if so, run it. - std::map<std::string, CLICommand*>::iterator CI2 = CI; - - // If the next command is a valid completion of this one, we are - // ambiguous. - if (++CI2 != CommandTable.end() && isValidPrefix(Command, CI2->first)) { - std::string ErrorMsg = - "Ambiguous command '" + Command + "'. Options: " + CI->first; - for (++CI; CI != CommandTable.end() && - isValidPrefix(Command, CI->first); ++CI) - ErrorMsg += ", " + CI->first; - throw ErrorMsg; - } else { - // It's an unambiguous prefix of a command, use it. - return CI->second; - } - } -} - - -/// run - Start the debugger, returning when the user exits the debugger. This -/// starts the main event loop of the CLI debugger. -/// -int CLIDebugger::run() { - std::string Command; - std::cout << Prompt; - - // Keep track of the last command issued, so that we can reissue it if the - // user hits enter as the command. - CLICommand *LastCommand = 0; - std::string LastArgs; - - // Continue reading commands until the end of file. - while (getline(std::cin, Command)) { - std::string Arguments = Command; - - // Split off the command from the arguments to the command. - Command = getToken(Arguments, " \t\n\v\f\r\\/;.*&"); - - try { - CLICommand *CurCommand; - - if (Command == "") { - CurCommand = LastCommand; - Arguments = LastArgs; - } else { - CurCommand = getCommand(Command); - } - - // Save the command we are running in case the user wants us to repeat it - // next time. - LastCommand = CurCommand; - LastArgs = Arguments; - - // Finally, execute the command. - if (CurCommand) - CurCommand->runCommand(*this, Arguments); - - } catch (int RetVal) { - // The quit command exits the command loop by throwing an integer return - // code. - return RetVal; - } catch (const std::string &Error) { - std::cout << "Error: " << Error << "\n"; - } catch (const char *Error) { - std::cout << "Error: " << Error << "\n"; - } catch (const NonErrorException &E) { - std::cout << E.getMessage() << "\n"; - } catch (...) { - std::cout << "ERROR: Debugger caught unexpected exception!\n"; - // Attempt to continue. - } - - // Write the prompt to get the next bit of user input - std::cout << Prompt; - } - - return 0; -} - - -/// askYesNo - Ask the user a question, and demand a yes/no response. If -/// the user says yes, return true. -/// -bool CLIDebugger::askYesNo(const std::string &Message) const { - std::string Answer; - std::cout << Message << " (y or n) " << std::flush; - while (getline(std::cin, Answer)) { - std::string Val = getToken(Answer); - if (getToken(Answer).empty()) { - if (Val == "yes" || Val == "y" || Val == "YES" || Val == "Y" || - Val == "Yes") - return true; - if (Val == "no" || Val == "n" || Val == "NO" || Val == "N" || - Val == "No") - return false; - } - - std::cout << "Please answer y or n.\n" << Message << " (y or n) " - << std::flush; - } - - // Ran out of input? - return false; -} diff --git a/llvm/tools/llvm-db/CLIDebugger.h b/llvm/tools/llvm-db/CLIDebugger.h deleted file mode 100644 index 0595b3debad..00000000000 --- a/llvm/tools/llvm-db/CLIDebugger.h +++ /dev/null @@ -1,208 +0,0 @@ -//===- CLIDebugger.h - LLVM Command Line Interface Debugger -----*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file 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; - struct SourceLanguage; - class ProgramInfo; - class RuntimeInfo; - class LLVMContext; - - /// CLIDebugger - This class implements the command line interface for the - /// LLVM debugger. - class CLIDebugger { - LLVMContext& Context; - - /// 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(LLVMContext& ctxt); - - /// 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(); - - /// 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); - - /// 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); - - /// parseProgramOptions - This method parses the Options string and loads it - /// as options to be passed to the program. This is used by the run command - /// and by 'set args'. - void parseProgramOptions(std::string &Options); - }; -} - -#endif diff --git a/llvm/tools/llvm-db/CMakeLists.txt b/llvm/tools/llvm-db/CMakeLists.txt deleted file mode 100644 index af64908171e..00000000000 --- a/llvm/tools/llvm-db/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -set(LLVM_LINK_COMPONENTS debugger) -set(LLVM_REQUIRES_EH 1) - -add_llvm_tool(llvm-db - CLIDebugger.cpp - Commands.cpp - llvm-db.cpp - ) diff --git a/llvm/tools/llvm-db/Commands.cpp b/llvm/tools/llvm-db/Commands.cpp deleted file mode 100644 index d759dddecd3..00000000000 --- a/llvm/tools/llvm-db/Commands.cpp +++ /dev/null @@ -1,866 +0,0 @@ -//===-- Commands.cpp - Implement various commands for the CLI -------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements many builtin user commands. -// -//===----------------------------------------------------------------------===// - -#include "CLIDebugger.h" -#include "CLICommand.h" -#include "llvm/Debugger/ProgramInfo.h" -#include "llvm/Debugger/RuntimeInfo.h" -#include "llvm/Debugger/SourceLanguage.h" -#include "llvm/Debugger/SourceFile.h" -#include "llvm/Debugger/InferiorProcess.h" -#include "llvm/Support/FileUtilities.h" -#include "llvm/Support/raw_ostream.h" -#include "llvm/ADT/StringExtras.h" -#include <cstdlib> -using namespace llvm; - -/// 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 &CLIDebugger::getCurrentLanguage() const { - // If the user explicitly switched languages with 'set language', use what - // they asked for. - if (CurrentLanguage) { - return *CurrentLanguage; - } else if (Dbg.isProgramRunning()) { - // Otherwise, if the program is running, infer the current language from it. - const GlobalVariable *FuncDesc = - getRuntimeInfo().getCurrentFrame().getFunctionDesc(); - return getProgramInfo().getFunction(FuncDesc).getSourceFile().getLanguage(); - } else { - // Otherwise, default to C like GDB apparently does. - return SourceLanguage::getCFamilyInstance(); - } -} - -/// startProgramRunning - If the program has been updated, reload it, then -/// start executing the program. -void CLIDebugger::startProgramRunning() { - eliminateRunInfo(); - - // If the program has been modified, reload it! - sys::PathWithStatus Program(Dbg.getProgramPath()); - std::string Err; - const sys::FileStatus *Status = Program.getFileStatus(false, &Err); - if (!Status) - throw Err; - if (TheProgramInfo->getProgramTimeStamp() != Status->getTimestamp()) { - outs() << "'" << Program.str() << "' has changed; re-reading program.\n"; - - // Unload an existing program. This kills the program if necessary. - Dbg.unloadProgram(); - delete TheProgramInfo; - TheProgramInfo = 0; - CurrentFile = 0; - - Dbg.loadProgram(Program.str(), Context); - TheProgramInfo = new ProgramInfo(Dbg.getProgram()); - } - - outs() << "Starting program: " << Dbg.getProgramPath() << "\n"; - Dbg.createProgram(); - - // There was no current frame. - LastCurrentFrame = 0; -} - -/// 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 CLIDebugger::printSourceLine(unsigned LineNo) { - assert(CurrentFile && "There is no current source file to print!"); - const char *LineStart, *LineEnd; - CurrentFile->getSourceLine(LineNo-1, LineStart, LineEnd); - if (LineStart == 0) return true; - outs() << LineNo; - - // If this is the line the program is currently stopped at, print a marker. - if (Dbg.isProgramRunning()) { - unsigned CurLineNo, CurColNo; - const SourceFileInfo *CurSFI; - getRuntimeInfo().getCurrentFrame().getSourceLocation(CurLineNo, CurColNo, - CurSFI); - - if (CurLineNo == LineNo && CurrentFile == &CurSFI->getSourceText()) - outs() << " ->"; - } - - outs() << "\t" << std::string(LineStart, LineEnd) << "\n"; - return false; -} - -/// printProgramLocation - Print a line of the place where the current stack -/// frame has stopped and the source line it is on. -/// -void CLIDebugger::printProgramLocation(bool PrintLocation) { - assert(Dbg.isProgramLoaded() && Dbg.isProgramRunning() && - "Error program is not loaded and running!"); - - // Figure out where the program stopped... - StackFrame &SF = getRuntimeInfo().getCurrentFrame(); - unsigned LineNo, ColNo; - const SourceFileInfo *FileDesc; - SF.getSourceLocation(LineNo, ColNo, FileDesc); - - // If requested, print out some program information about WHERE we are. - if (PrintLocation) { - // FIXME: print the current function arguments - if (const GlobalVariable *FuncDesc = SF.getFunctionDesc()) - outs() << getProgramInfo().getFunction(FuncDesc).getSymbolicName(); - else - outs() << "<unknown function>"; - - CurrentFile = &FileDesc->getSourceText(); - - outs() << " at " << CurrentFile->getFilename() << ":" << LineNo; - if (ColNo) outs() << ":" << ColNo; - outs() << "\n"; - } - - if (printSourceLine(LineNo)) - outs() << "<could not load source file>\n"; - else { - LineListedStart = LineNo-ListSize/2+1; - if ((int)LineListedStart < 1) LineListedStart = 1; - LineListedEnd = LineListedStart+1; - } -} - -/// eliminateRunInfo - We are about to run the program. Forget any state -/// about how the program used to be stopped. -void CLIDebugger::eliminateRunInfo() { - delete TheRuntimeInfo; - TheRuntimeInfo = 0; -} - -/// programStoppedSuccessfully - This method updates internal data -/// structures to reflect the fact that the program just executed a while, -/// and has successfully stopped. -void CLIDebugger::programStoppedSuccessfully() { - assert(TheRuntimeInfo==0 && "Someone forgot to release the old RuntimeInfo!"); - - TheRuntimeInfo = new RuntimeInfo(TheProgramInfo, Dbg.getRunningProcess()); - - // FIXME: if there are any breakpoints at the current location, print them as - // well. - - // Since the program as successfully stopped, print its location. - void *CurrentFrame = getRuntimeInfo().getCurrentFrame().getFrameID(); - printProgramLocation(CurrentFrame != LastCurrentFrame); - LastCurrentFrame = CurrentFrame; -} - - - -/// getUnsignedIntegerOption - Get an unsigned integer number from the Val -/// string. Check to make sure that the string contains an unsigned integer -/// token, and if not, throw an exception. If isOnlyOption is set, also throw -/// an exception if there is extra junk at the end of the string. -static unsigned getUnsignedIntegerOption(const char *Msg, std::string &Val, - bool isOnlyOption = true) { - std::string Tok = getToken(Val); - if (Tok.empty() || (isOnlyOption && !getToken(Val).empty())) - throw std::string(Msg) + " expects an unsigned integer argument."; - - char *EndPtr; - unsigned Result = strtoul(Tok.c_str(), &EndPtr, 0); - if (EndPtr != Tok.c_str()+Tok.size()) - throw std::string(Msg) + " expects an unsigned integer argument."; - - return Result; -} - -/// getOptionalUnsignedIntegerOption - This method is just like -/// getUnsignedIntegerOption, but if the argument value is not specified, a -/// default is returned instead of causing an error. -static unsigned -getOptionalUnsignedIntegerOption(const char *Msg, unsigned Default, - std::string &Val, bool isOnlyOption = true) { - // Check to see if the value was specified... - std::string TokVal = getToken(Val); - if (TokVal.empty()) return Default; - - // If it was specified, add it back to the value we are parsing... - Val = TokVal+Val; - - // And parse normally. - return getUnsignedIntegerOption(Msg, Val, isOnlyOption); -} - - -/// parseProgramOptions - This method parses the Options string and loads it -/// as options to be passed to the program. This is used by the run command -/// and by 'set args'. -void CLIDebugger::parseProgramOptions(std::string &Options) { - // FIXME: tokenizing by whitespace is clearly incorrect. Instead we should - // honor quotes and other things that a shell would. Also in the future we - // should support redirection of standard IO. - - std::vector<std::string> Arguments; - for (std::string A = getToken(Options); !A.empty(); A = getToken(Options)) - Arguments.push_back(A); - Dbg.setProgramArguments(Arguments.begin(), Arguments.end()); -} - - -//===----------------------------------------------------------------------===// -// Program startup and shutdown options -//===----------------------------------------------------------------------===// - - -/// file command - If the user specifies an option, search the PATH for the -/// specified program/bitcode file and load it. If the user does not specify -/// an option, unload the current program. -void CLIDebugger::fileCommand(std::string &Options) { - std::string Prog = getToken(Options); - if (!getToken(Options).empty()) - throw "file command takes at most one argument."; - - // Check to make sure the user knows what they are doing - if (Dbg.isProgramRunning() && - !askYesNo("A program is already loaded. Kill it?")) - return; - - // Unload an existing program. This kills the program if necessary. - eliminateRunInfo(); - delete TheProgramInfo; - TheProgramInfo = 0; - Dbg.unloadProgram(); - CurrentFile = 0; - - // If requested, start the new program. - if (Prog.empty()) { - outs() << "Unloaded program.\n"; - } else { - outs() << "Loading program... "; - outs().flush(); - Dbg.loadProgram(Prog, Context); - assert(Dbg.isProgramLoaded() && - "loadProgram succeeded, but not program loaded!"); - TheProgramInfo = new ProgramInfo(Dbg.getProgram()); - outs() << "successfully loaded '" << Dbg.getProgramPath() << "'!\n"; - } -} - - -void CLIDebugger::createCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "create command does not take any arguments."; - if (!Dbg.isProgramLoaded()) throw "No program loaded."; - if (Dbg.isProgramRunning() && - !askYesNo("The program is already running. Restart from the beginning?")) - return; - - // Start the program running. - startProgramRunning(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::killCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "kill command does not take any arguments."; - if (!Dbg.isProgramRunning()) - throw "No program is currently being run."; - - if (askYesNo("Kill the program being debugged?")) - Dbg.killProgram(); - eliminateRunInfo(); -} - -void CLIDebugger::quitCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "quit command does not take any arguments."; - - if (Dbg.isProgramRunning() && - !askYesNo("The program is running. Exit anyway?")) - return; - - // Throw exception to get out of the user-input loop. - throw 0; -} - - -//===----------------------------------------------------------------------===// -// Program execution commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::runCommand(std::string &Options) { - if (!Dbg.isProgramLoaded()) throw "No program loaded."; - if (Dbg.isProgramRunning() && - !askYesNo("The program is already running. Restart from the beginning?")) - return; - - // Parse all of the options to the run command, which specify program - // arguments to run with. - parseProgramOptions(Options); - - eliminateRunInfo(); - - // Start the program running. - startProgramRunning(); - - // Start the program running... - Options = ""; - contCommand(Options); -} - -void CLIDebugger::contCommand(std::string &Options) { - if (!getToken(Options).empty()) throw "cont argument not supported yet."; - if (!Dbg.isProgramRunning()) throw "Program is not running."; - - eliminateRunInfo(); - - Dbg.contProgram(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::stepCommand(std::string &Options) { - if (!Dbg.isProgramRunning()) throw "Program is not running."; - - // Figure out how many times to step. - unsigned Amount = - getOptionalUnsignedIntegerOption("'step' command", 1, Options); - - eliminateRunInfo(); - - // Step the specified number of times. - for (; Amount; --Amount) - Dbg.stepProgram(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::nextCommand(std::string &Options) { - if (!Dbg.isProgramRunning()) throw "Program is not running."; - unsigned Amount = - getOptionalUnsignedIntegerOption("'next' command", 1, Options); - - eliminateRunInfo(); - - for (; Amount; --Amount) - Dbg.nextProgram(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::finishCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "finish command does not take any arguments."; - if (!Dbg.isProgramRunning()) throw "Program is not running."; - - // Figure out where we are exactly. If the user requests that we return from - // a frame that is not the top frame, make sure we get it. - void *CurrentFrame = getRuntimeInfo().getCurrentFrame().getFrameID(); - - eliminateRunInfo(); - - Dbg.finishProgram(CurrentFrame); - - // The program stopped! - programStoppedSuccessfully(); -} - -//===----------------------------------------------------------------------===// -// Stack frame commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::backtraceCommand(std::string &Options) { - // Accepts "full", n, -n - if (!getToken(Options).empty()) - throw "FIXME: bt command argument not implemented yet!"; - - RuntimeInfo &RI = getRuntimeInfo(); - ProgramInfo &PI = getProgramInfo(); - - try { - for (unsigned i = 0; ; ++i) { - StackFrame &SF = RI.getStackFrame(i); - outs() << "#" << i; - if (i == RI.getCurrentFrameIdx()) - outs() << " ->"; - outs() << "\t" << SF.getFrameID() << " in "; - if (const GlobalVariable *G = SF.getFunctionDesc()) - outs() << PI.getFunction(G).getSymbolicName(); - - unsigned LineNo, ColNo; - const SourceFileInfo *SFI; - SF.getSourceLocation(LineNo, ColNo, SFI); - if (!SFI->getBaseName().empty()) { - outs() << " at " << SFI->getBaseName(); - if (LineNo) { - outs() << ":" << LineNo; - if (ColNo) - outs() << ":" << ColNo; - } - } - - // FIXME: when we support shared libraries, we should print ' from foo.so' - // if the stack frame is from a different object than the current one. - - outs() << "\n"; - } - } catch (...) { - // Stop automatically when we run off the bottom of the stack. - } -} - -void CLIDebugger::upCommand(std::string &Options) { - unsigned Num = - getOptionalUnsignedIntegerOption("'up' command", 1, Options); - - RuntimeInfo &RI = getRuntimeInfo(); - unsigned CurFrame = RI.getCurrentFrameIdx(); - - // Check to see if we go can up the specified number of frames. - try { - RI.getStackFrame(CurFrame+Num); - } catch (...) { - if (Num == 1) - throw "Initial frame selected; you cannot go up."; - else - throw "Cannot go up " + utostr(Num) + " frames!"; - } - - RI.setCurrentFrameIdx(CurFrame+Num); - printProgramLocation(); -} - -void CLIDebugger::downCommand(std::string &Options) { - unsigned Num = - getOptionalUnsignedIntegerOption("'down' command", 1, Options); - - RuntimeInfo &RI = getRuntimeInfo(); - unsigned CurFrame = RI.getCurrentFrameIdx(); - - // Check to see if we can go up the specified number of frames. - if (CurFrame < Num) { - if (Num == 1) - throw "Bottom (i.e., innermost) frame selected; you cannot go down."; - else - throw "Cannot go down " + utostr(Num) + " frames!"; - } - - RI.setCurrentFrameIdx(CurFrame-Num); - printProgramLocation(); -} - -void CLIDebugger::frameCommand(std::string &Options) { - RuntimeInfo &RI = getRuntimeInfo(); - unsigned CurFrame = RI.getCurrentFrameIdx(); - - unsigned Num = - getOptionalUnsignedIntegerOption("'frame' command", CurFrame, Options); - - // Check to see if we go to the specified frame. - RI.getStackFrame(Num); - - RI.setCurrentFrameIdx(Num); - printProgramLocation(); -} - - -//===----------------------------------------------------------------------===// -// Breakpoint related commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::breakCommand(std::string &Options) { - // Figure out where the user wants a breakpoint. - const SourceFile *File; - unsigned LineNo; - - // Check to see if the user specified a line specifier. - std::string Option = getToken(Options); // strip whitespace - if (!Option.empty()) { - Options = Option + Options; // reconstruct string - - // Parse the line specifier. - parseLineSpec(Options, File, LineNo); - } else { - // Build a line specifier for the current stack frame. - throw "FIXME: breaking at the current location is not implemented yet!"; - } - - if (!File) File = CurrentFile; - if (File == 0) - throw "Unknown file to place breakpoint!"; - - errs() << "Break: " << File->getFilename() << ":" << LineNo << "\n"; - - throw "breakpoints not implemented yet!"; -} - -//===----------------------------------------------------------------------===// -// Miscellaneous commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::infoCommand(std::string &Options) { - std::string What = getToken(Options); - - if (What.empty() || !getToken(Options).empty()){ - std::string infoStr("info"); - helpCommand(infoStr); - return; - } - - if (What == "frame") { - } else if (What == "functions") { - const std::map<const GlobalVariable*, SourceFunctionInfo*> &Functions - = getProgramInfo().getSourceFunctions(); - outs() << "All defined functions:\n"; - // FIXME: GDB groups these by source file. We could do that I guess. - for (std::map<const GlobalVariable*, SourceFunctionInfo*>::const_iterator - I = Functions.begin(), E = Functions.end(); I != E; ++I) { - outs() << I->second->getSymbolicName() << "\n"; - } - - } else if (What == "source") { - if (CurrentFile == 0) - throw "No current source file."; - - // Get the SourceFile information for the current file. - const SourceFileInfo &SF = - getProgramInfo().getSourceFile(CurrentFile->getDescriptor()); - - outs() << "Current source file is: " << SF.getBaseName() << "\n" - << "Compilation directory is: " << SF.getDirectory() << "\n"; - if (unsigned NL = CurrentFile->getNumLines()) - outs() << "Located in: " << CurrentFile->getFilename() << "\n" - << "Contains " << NL << " lines\n"; - else - outs() << "Could not find source file.\n"; - outs() << "Source language is " - << SF.getLanguage().getSourceLanguageName() << "\n"; - - } else if (What == "sources") { - const std::map<const GlobalVariable*, SourceFileInfo*> &SourceFiles = - getProgramInfo().getSourceFiles(); - outs() << "Source files for the program:\n"; - for (std::map<const GlobalVariable*, SourceFileInfo*>::const_iterator I = - SourceFiles.begin(), E = SourceFiles.end(); I != E;) { - outs() << I->second->getDirectory() << "/" - << I->second->getBaseName(); - ++I; - if (I != E) outs() << ", "; - } - outs() << "\n"; - } else if (What == "target") { - outs() << Dbg.getRunningProcess().getStatus(); - } else { - // See if this is something handled by the current language. - if (getCurrentLanguage().printInfo(What)) - return; - - throw "Unknown info command '" + What + "'. Try 'help info'."; - } -} - -/// 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 CLIDebugger::parseLineSpec(std::string &LineSpec, - const SourceFile *&SourceFile, - unsigned &LineNo) { - SourceFile = 0; - LineNo = 0; - - // First, check to see if we have a : separator. - std::string FirstPart = getToken(LineSpec, ":"); - std::string SecondPart = getToken(LineSpec, ":"); - if (!getToken(LineSpec).empty()) throw "Malformed line specification!"; - - // If there is no second part, we must have either "function", "number", - // "+offset", or "-offset". - if (SecondPart.empty()) { - if (FirstPart.empty()) throw "Malformed line specification!"; - if (FirstPart[0] == '+') { - FirstPart.erase(FirstPart.begin(), FirstPart.begin()+1); - // For +n, return LineListedEnd+n - LineNo = LineListedEnd + - getUnsignedIntegerOption("Line specifier '+'", FirstPart); - - } else if (FirstPart[0] == '-') { - FirstPart.erase(FirstPart.begin(), FirstPart.begin()+1); - // For -n, return LineListedEnd-n - LineNo = LineListedEnd - - getUnsignedIntegerOption("Line specifier '-'", FirstPart); - if ((int)LineNo < 1) LineNo = 1; - } else if (FirstPart[0] == '*') { - throw "Address expressions not supported as source locations!"; - } else { - // Ok, check to see if this is just a line number. - std::string Saved = FirstPart; - try { - LineNo = getUnsignedIntegerOption("", Saved); - } catch (...) { - // Ok, it's not a valid line number. It must be a source-language - // entity name. - std::string Name = getToken(FirstPart); - if (!getToken(FirstPart).empty()) - throw "Extra junk in line specifier after '" + Name + "'."; - SourceFunctionInfo *SFI = - getCurrentLanguage().lookupFunction(Name, getProgramInfo(), - TheRuntimeInfo); - if (SFI == 0) - throw "Unknown identifier '" + Name + "'."; - - unsigned L, C; - SFI->getSourceLocation(L, C); - if (L == 0) throw "Could not locate '" + Name + "'!"; - LineNo = L; - SourceFile = &SFI->getSourceFile().getSourceText(); - return; - } - } - - } else { - // Ok, this must be a filename qualified line number or function name. - // First, figure out the source filename. - std::string SourceFilename = getToken(FirstPart); - if (!getToken(FirstPart).empty()) - throw "Invalid filename qualified source location!"; - - // Next, check to see if this is just a line number. - std::string Saved = SecondPart; - try { - LineNo = getUnsignedIntegerOption("", Saved); - } catch (...) { - // Ok, it's not a valid line number. It must be a function name. - throw "FIXME: Filename qualified function names are not support " - "as line specifiers yet!"; - } - - // Ok, we got the line number. Now check out the source file name to make - // sure it's all good. If it is, return it. If not, throw exception. - SourceFile =&getProgramInfo().getSourceFile(SourceFilename).getSourceText(); - } -} - -void CLIDebugger::listCommand(std::string &Options) { - if (!Dbg.isProgramLoaded()) - throw "No program is loaded. Use the 'file' command."; - - // Handle "list foo," correctly, by returning " " as the second token - Options += " "; - - std::string FirstLineSpec = getToken(Options, ","); - std::string SecondLineSpec = getToken(Options, ","); - if (!getToken(Options, ",").empty()) - throw "list command only expects two source location specifiers!"; - - // StartLine, EndLine - The starting and ending line numbers to print. - unsigned StartLine = 0, EndLine = 0; - - if (SecondLineSpec.empty()) { // No second line specifier provided? - // Handle special forms like "", "+", "-", etc. - std::string TmpSpec = FirstLineSpec; - std::string Tok = getToken(TmpSpec); - if (getToken(TmpSpec).empty() && (Tok == "" || Tok == "+" || Tok == "-")) { - if (Tok == "+" || Tok == "") { - StartLine = LineListedEnd; - EndLine = StartLine + ListSize; - } else { - assert(Tok == "-"); - StartLine = LineListedStart-ListSize; - EndLine = LineListedStart; - if ((int)StartLine <= 0) StartLine = 1; - } - } else { - // Must be a normal line specifier. - const SourceFile *File; - unsigned LineNo; - parseLineSpec(FirstLineSpec, File, LineNo); - - // If the user only specified one file specifier, we should display - // ListSize lines centered at the specified line. - if (File != 0) CurrentFile = File; - StartLine = LineNo - (ListSize+1)/2; - if ((int)StartLine <= 0) StartLine = 1; - EndLine = StartLine + ListSize; - } - - } else { - // Parse two line specifiers... - const SourceFile *StartFile, *EndFile; - unsigned StartLineNo, EndLineNo; - parseLineSpec(FirstLineSpec, StartFile, StartLineNo); - unsigned SavedLLE = LineListedEnd; - LineListedEnd = StartLineNo; - try { - parseLineSpec(SecondLineSpec, EndFile, EndLineNo); - } catch (...) { - LineListedEnd = SavedLLE; - throw; - } - - // Inherit file specified by the first line spec if there was one. - if (EndFile == 0) EndFile = StartFile; - - if (StartFile != EndFile) - throw "Start and end line specifiers are in different files!"; - CurrentFile = StartFile; - StartLine = StartLineNo; - EndLine = EndLineNo+1; - } - - assert((int)StartLine > 0 && (int)EndLine > 0 && StartLine <= EndLine && - "Error reading line specifiers!"); - - // If there was no current file, and the user didn't specify one to list, we - // have an error. - if (CurrentFile == 0) - throw "There is no current file to list."; - - // Remember for next time. - LineListedStart = StartLine; - LineListedEnd = StartLine; - - for (unsigned LineNo = StartLine; LineNo != EndLine; ++LineNo) { - // Print the source line, unless it is invalid. - if (printSourceLine(LineNo)) - break; - LineListedEnd = LineNo+1; - } - - // If we didn't print any lines, find out why. - if (LineListedEnd == StartLine) { - // See if we can read line #0 from the file, if not, we couldn't load the - // file. - const char *LineStart, *LineEnd; - CurrentFile->getSourceLine(0, LineStart, LineEnd); - if (LineStart == 0) - throw "Could not load source file '" + CurrentFile->getFilename() + "'!"; - else - outs() << "<end of file>\n"; - } -} - -void CLIDebugger::setCommand(std::string &Options) { - std::string What = getToken(Options); - - if (What.empty()) - throw "set command expects at least two arguments."; - if (What == "args") { - parseProgramOptions(Options); - } else if (What == "language") { - std::string Lang = getToken(Options); - if (!getToken(Options).empty()) - throw "set language expects one argument at most."; - if (Lang == "") { - outs() << "The currently understood settings are:\n\n" - << "local or auto Automatic setting based on source file\n" - << "c Use the C language\n" - << "c++ Use the C++ language\n" - << "unknown Use when source language is not supported\n"; - } else if (Lang == "local" || Lang == "auto") { - CurrentLanguage = 0; - } else if (Lang == "c") { - CurrentLanguage = &SourceLanguage::getCFamilyInstance(); - } else if (Lang == "c++") { - CurrentLanguage = &SourceLanguage::getCPlusPlusInstance(); - } else if (Lang == "unknown") { - CurrentLanguage = &SourceLanguage::getUnknownLanguageInstance(); - } else { - throw "Unknown language '" + Lang + "'."; - } - - } else if (What == "listsize") { - ListSize = getUnsignedIntegerOption("'set prompt' command", Options); - } else if (What == "prompt") { - // Include any trailing whitespace or other tokens, but not leading - // whitespace. - Prompt = getToken(Options); // Strip leading whitespace - Prompt += Options; // Keep trailing whitespace or other stuff - } else { - // FIXME: Try to parse this as a source-language program expression. - throw "Don't know how to set '" + What + "'!"; - } -} - -void CLIDebugger::showCommand(std::string &Options) { - std::string What = getToken(Options); - - if (What.empty() || !getToken(Options).empty()) - throw "show command expects one argument."; - - if (What == "args") { - outs() << "Argument list to give program when started is \""; - // FIXME: This doesn't print stuff correctly if the arguments have spaces in - // them, but currently the only way to get that is to use the --args command - // line argument. This should really handle escaping all hard characters as - // needed. - for (unsigned i = 0, e = Dbg.getNumProgramArguments(); i != e; ++i) - outs() << (i ? " " : "") << Dbg.getProgramArgument(i); - outs() << "\"\n"; - - } else if (What == "language") { - outs() << "The current source language is '"; - if (CurrentLanguage) - outs() << CurrentLanguage->getSourceLanguageName(); - else - outs() << "auto; currently " - << getCurrentLanguage().getSourceLanguageName(); - outs() << "'.\n"; - } else if (What == "listsize") { - outs() << "Number of source lines llvm-db will list by default is " - << ListSize << ".\n"; - } else if (What == "prompt") { - outs() << "llvm-db's prompt is \"" << Prompt << "\".\n"; - } else { - throw "Unknown show command '" + What + "'. Try 'help show'."; - } -} - -void CLIDebugger::helpCommand(std::string &Options) { - // Print out all of the commands in the CommandTable - std::string Command = getToken(Options); - if (!getToken(Options).empty()) - throw "help command takes at most one argument."; - - // Getting detailed help on a particular command? - if (!Command.empty()) { - CLICommand *C = getCommand(Command); - outs() << C->getShortHelp() << ".\n" << C->getLongHelp(); - - // If there are aliases for this option, print them out. - const std::vector<std::string> &Names = C->getOptionNames(); - if (Names.size() > 1) { - outs() << "The '" << Command << "' command is known as: '" - << Names[0] << "'"; - for (unsigned i = 1, e = Names.size(); i != e; ++i) - outs() << ", '" << Names[i] << "'"; - outs() << "\n"; - } - - } else { - unsigned MaxSize = 0; - for (std::map<std::string, CLICommand*>::iterator I = CommandTable.begin(), - E = CommandTable.end(); I != E; ++I) - if (I->first.size() > MaxSize && - I->first == I->second->getPrimaryOptionName()) - MaxSize = I->first.size(); - - // Loop over all of the commands, printing the short help version - for (std::map<std::string, CLICommand*>::iterator I = CommandTable.begin(), - E = CommandTable.end(); I != E; ++I) - if (I->first == I->second->getPrimaryOptionName()) - outs() << I->first << std::string(MaxSize - I->first.size(), ' ') - << " - " << I->second->getShortHelp() << "\n"; - } -} diff --git a/llvm/tools/llvm-db/Makefile b/llvm/tools/llvm-db/Makefile deleted file mode 100644 index df8164944f0..00000000000 --- a/llvm/tools/llvm-db/Makefile +++ /dev/null @@ -1,15 +0,0 @@ -##===- tools/llvm-db/Makefile ------------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LEVEL = ../.. -TOOLNAME = llvm-db -LINK_COMPONENTS := debugger -REQUIRES_EH := 1 - -include $(LEVEL)/Makefile.common diff --git a/llvm/tools/llvm-db/llvm-db.cpp b/llvm/tools/llvm-db/llvm-db.cpp deleted file mode 100644 index 463a1bdf884..00000000000 --- a/llvm/tools/llvm-db/llvm-db.cpp +++ /dev/null @@ -1,102 +0,0 @@ -//===- llvm-db.cpp - LLVM Debugger ----------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This utility implements a simple text-mode front-end to the LLVM debugger -// library. -// -//===----------------------------------------------------------------------===// - -#include "CLIDebugger.h" -#include "llvm/LLVMContext.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/raw_ostream.h" -#include "llvm/System/Signals.h" -using namespace llvm; - -namespace { - // Command line options for specifying the program to debug and options to use - cl::opt<std::string> - InputFile(cl::desc("<program>"), cl::Positional, cl::init("")); - - cl::list<std::string> - InputArgs("args", cl::Positional, cl::desc("<program and arguments>"), - cl::ZeroOrMore); - - // Command line options to control various directory related stuff - cl::list<std::string> - SourceDirectories("directory", cl::value_desc("directory"), - cl::desc("Add directory to the search for source files")); - cl::alias SDA("d", cl::desc("Alias for --directory"), - cl::aliasopt(SourceDirectories)); - - cl::opt<std::string> - WorkingDirectory("cd", cl::desc("Use directory as current working directory"), - cl::value_desc("directory")); - - // Command line options specific to the llvm-db debugger driver - cl::opt<bool> Quiet("quiet", cl::desc("Do not print introductory messages")); - cl::alias QA1("silent", cl::desc("Alias for -quiet"), cl::aliasopt(Quiet)); - cl::alias QA2("q", cl::desc("Alias for -quiet"), cl::aliasopt(Quiet)); -} - -//===----------------------------------------------------------------------===// -// main Driver function -// -int main(int argc, char **argv, char * const *envp) { - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(); - PrettyStackTraceProgram X(argc, argv); - - LLVMContext &Context = getGlobalContext(); - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - outs() << "NOTE: llvm-db is known useless right now.\n"; - try { - cl::ParseCommandLineOptions(argc, argv, - "llvm source-level debugger\n"); - - if (!Quiet) - outs() << "llvm-db: The LLVM source-level debugger\n"; - - // Merge Inputfile and InputArgs into the InputArgs list... - if (!InputFile.empty() && InputArgs.empty()) - InputArgs.push_back(InputFile); - - // Create the CLI debugger... - CLIDebugger D(Context); - - // Initialize the debugger with the command line options we read... - Debugger &Dbg = D.getDebugger(); - - // Initialize the debugger environment. - Dbg.initializeEnvironment(envp); - Dbg.setWorkingDirectory(WorkingDirectory); - for (unsigned i = 0, e = SourceDirectories.size(); i != e; ++i) - D.addSourceDirectory(SourceDirectories[i]); - - if (!InputArgs.empty()) { - try { - D.fileCommand(InputArgs[0]); - } catch (const std::string &Error) { - outs() << "Error: " << Error << "\n"; - } - - Dbg.setProgramArguments(InputArgs.begin()+1, InputArgs.end()); - } - - // Now that we have initialized the debugger, run it. - return D.run(); - } catch (const std::string& msg) { - errs() << argv[0] << ": " << msg << "\n"; - } catch (...) { - errs() << argv[0] << ": Unexpected unknown exception occurred.\n"; - } - return 1; -} |
