remove llvm-db: it is completely broken and if anyone wants to do a debugger,

they should not base it on llvm-db (which not following almost any "best practices").


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@83288 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 0 insertions, 176 deletions

diff --git a/include/llvm/Debugger/Debugger.h b/include/llvm/Debugger/Debugger.h
deleted file mode 100644
index 42de35660c..0000000000
--- a/include/llvm/Debugger/Debugger.h
+++ /dev/null
@@ -1,176 +0,0 @@
-//===- Debugger.h - LLVM debugger library interface -------------*- 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 LLVM source-level debugger library interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEBUGGER_DEBUGGER_H
-#define LLVM_DEBUGGER_DEBUGGER_H
-
-#include <string>
-#include <vector>
-
-namespace llvm {
-  class Module;
-  class InferiorProcess;
-  class LLVMContext;
-
-  /// Debugger class - This class implements the LLVM source-level debugger.
-  /// This allows clients to handle the user IO processing without having to
-  /// worry about how the debugger itself works.
-  ///
-  class Debugger {
-    // State the debugger needs when starting and stopping the program.
-    std::vector<std::string> ProgramArguments;
-
-    // The environment to run the program with.  This should eventually be
-    // changed to vector of strings when we allow the user to edit the
-    // environment.
-    const char * const *Environment;
-
-    // Program - The currently loaded program, or null if none is loaded.
-    Module *Program;
-
-    // Process - The currently executing inferior process.
-    InferiorProcess *Process;
-
-    Debugger(const Debugger &);         // DO NOT IMPLEMENT
-    void operator=(const Debugger &);   // DO NOT IMPLEMENT
-  public:
-    Debugger();
-    ~Debugger();
-
-    //===------------------------------------------------------------------===//
-    // Methods for manipulating and inspecting the execution environment.
-    //
-
-    /// initializeEnvironment - Specify the environment the program should run
-    /// with.  This is used to initialize the environment of the program to the
-    /// environment of the debugger.
-    void initializeEnvironment(const char *const *envp) {
-      Environment = envp;
-    }
-
-    /// setWorkingDirectory - Specify the working directory for the program to
-    /// be started from.
-    void setWorkingDirectory(const std::string &Dir) {
-      // FIXME: implement
-    }
-
-    template<typename It>
-    void setProgramArguments(It I, It E) {
-      ProgramArguments.assign(I, E);
-    }
-    unsigned getNumProgramArguments() const {
-      return static_cast<unsigned>(ProgramArguments.size());
-    }
-    const std::string &getProgramArgument(unsigned i) const {
-      return ProgramArguments[i];
-    }
-
-
-    //===------------------------------------------------------------------===//
-    // Methods for manipulating and inspecting the program currently loaded.
-    //
-
-    /// isProgramLoaded - Return true if there is a program currently loaded.
-    ///
-    bool isProgramLoaded() const { return Program != 0; }
-
-    /// getProgram - Return the LLVM module corresponding to the program.
-    ///
-    Module *getProgram() const { return Program; }
-
-    /// getProgramPath - Get the path of the currently loaded program, or an
-    /// empty string if none is loaded.
-    std::string getProgramPath() const;
-
-    /// loadProgram - If a program is currently loaded, unload it.  Then search
-    /// the PATH for the specified program, loading it when found.  If the
-    /// specified program cannot be found, an exception is thrown to indicate
-    /// the error.
-    void loadProgram(const std::string &Path, LLVMContext& Context);
-
-    /// unloadProgram - If a program is running, kill it, then unload all traces
-    /// of the current program.  If no program is loaded, this method silently
-    /// succeeds.
-    void unloadProgram();
-
-    //===------------------------------------------------------------------===//
-    // Methods for manipulating and inspecting the program currently running.
-    //
-    // If the program is running, and the debugger is active, then we know that
-    // the program has stopped.  This being the case, we can inspect the
-    // program, ask it for its source location, set breakpoints, etc.
-    //
-
-    /// isProgramRunning - Return true if a program is loaded and has a
-    /// currently active instance.
-    bool isProgramRunning() const { return Process != 0; }
-
-    /// getRunningProcess - If there is no program running, throw an exception.
-    /// Otherwise return the running process so that it can be inspected by the
-    /// debugger.
-    const InferiorProcess &getRunningProcess() const {
-      if (Process == 0) throw "No process running.";
-      return *Process;
-    }
-
-    /// createProgram - Create an instance of the currently loaded program,
-    /// killing off any existing one.  This creates the program and stops it at
-    /// the first possible moment.  If there is no program loaded or if there is
-    /// a problem starting the program, this method throws an exception.
-    void createProgram();
-
-    /// killProgram - If the program is currently executing, kill off the
-    /// process and free up any state related to the currently running program.
-    /// If there is no program currently running, this just silently succeeds.
-    /// If something horrible happens when killing the program, an exception
-    /// gets thrown.
-    void killProgram();
-
-
-    //===------------------------------------------------------------------===//
-    // Methods for continuing execution.  These methods continue the execution
-    // of the program by some amount.  If the program is successfully stopped,
-    // execution returns, otherwise an exception is thrown.
-    //
-    // NOTE: These methods should always be used in preference to directly
-    // accessing the Dbg object, because these will delete the Process object if
-    // the process unexpectedly dies.
-    //
-
-    /// stepProgram - Implement the 'step' command, continuing execution until
-    /// the next possible stop point.
-    void stepProgram();
-
-    /// nextProgram - Implement the 'next' command, continuing execution until
-    /// the next possible stop point that is in the current function.
-    void nextProgram();
-
-    /// finishProgram - Implement the 'finish' command, continuing execution
-    /// until the specified frame ID returns.
-    void finishProgram(void *Frame);
-
-    /// contProgram - Implement the 'cont' command, continuing execution until
-    /// the next breakpoint is encountered.
-    void contProgram();
-  };
-
-  class NonErrorException {
-    std::string Message;
-  public:
-    NonErrorException(const std::string &M) : Message(M) {}
-    const std::string &getMessage() const { return Message; }
-  };
-
-} // end namespace llvm
-
-#endif