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, 246 deletions

diff --git a/include/llvm/Debugger/ProgramInfo.h b/include/llvm/Debugger/ProgramInfo.h
deleted file mode 100644
index 8f31d7f135..0000000000
--- a/include/llvm/Debugger/ProgramInfo.h
+++ /dev/null
@@ -1,246 +0,0 @@
-//===- ProgramInfo.h - Information about the loaded program -----*- 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 various pieces of information about the currently loaded
-// program.  One instance of this object is created every time a program is
-// loaded, and destroyed every time it is unloaded.
-//
-// The various pieces of information gathered about the source program are all
-// designed to be extended by various SourceLanguage implementations.  This
-// allows source languages to keep any extended information that they support in
-// the derived class portions of the class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEBUGGER_PROGRAMINFO_H
-#define LLVM_DEBUGGER_PROGRAMINFO_H
-
-#include "llvm/System/TimeValue.h"
-#include <string>
-#include <map>
-#include <vector>
-
-namespace llvm {
-  class GlobalVariable;
-  class Module;
-  class SourceFile;
-  struct SourceLanguage;
-  class ProgramInfo;
-
-  /// SourceLanguageCache - SourceLanguage implementations are allowed to cache
-  /// stuff in the ProgramInfo object.  The only requirement we have on these
-  /// instances is that they are destroyable.
-  struct SourceLanguageCache {
-    virtual ~SourceLanguageCache() {}
-  };
-
-  /// SourceFileInfo - One instance of this structure is created for each
-  /// source file in the program.
-  ///
-  class SourceFileInfo {
-    /// BaseName - The filename of the source file.
-    std::string BaseName;
-
-    /// Directory - The working directory of this source file when it was
-    /// compiled.
-    std::string Directory;
-
-    /// Version - The version of the LLVM debug information that this file was
-    /// compiled with.
-    unsigned Version;
-
-    /// Language - The source language that the file was compiled with.  This
-    /// pointer is never null.
-    ///
-    const SourceLanguage *Language;
-
-    /// Descriptor - The LLVM Global Variable which describes the source file.
-    ///
-    const GlobalVariable *Descriptor;
-
-    /// SourceText - The body of this source file, or null if it has not yet
-    /// been loaded.
-    mutable SourceFile *SourceText;
-  public:
-    SourceFileInfo(const GlobalVariable *Desc, const SourceLanguage &Lang);
-    ~SourceFileInfo();
-
-    const std::string &getBaseName() const { return BaseName; }
-    const std::string &getDirectory() const { return Directory; }
-    unsigned getDebugVersion() const { return Version; }
-    const GlobalVariable *getDescriptor() const { return Descriptor; }
-    SourceFile &getSourceText() const;
-
-    const SourceLanguage &getLanguage() const { return *Language; }
-  };
-
-
-  /// SourceFunctionInfo - An instance of this class is used to represent each
-  /// source function in the program.
-  ///
-  class SourceFunctionInfo {
-    /// Name - This contains an abstract name that is potentially useful to the
-    /// end-user.  If there is no explicit support for the current language,
-    /// then this string is used to identify the function.
-    std::string Name;
-
-    /// Descriptor - The descriptor for this function.
-    ///
-    const GlobalVariable *Descriptor;
-
-    /// SourceFile - The file that this function is defined in.
-    ///
-    const SourceFileInfo *SourceFile;
-
-    /// LineNo, ColNo - The location of the first stop-point in the function.
-    /// These are computed on demand.
-    mutable unsigned LineNo, ColNo;
-
-  public:
-    SourceFunctionInfo(ProgramInfo &PI, const GlobalVariable *Desc);
-    virtual ~SourceFunctionInfo() {}
-
-    /// getSymbolicName - Return a human-readable symbolic name to identify the
-    /// function (for example, in stack traces).
-    virtual std::string getSymbolicName() const { return Name; }
-
-    /// getDescriptor - This returns the descriptor for the function.
-    ///
-    const GlobalVariable *getDescriptor() const { return Descriptor; }
-
-    /// getSourceFile - This returns the source file that defines the function.
-    ///
-    const SourceFileInfo &getSourceFile() const { return *SourceFile; }
-
-    /// getSourceLocation - This method returns the location of the first
-    /// stopping point in the function.  If the body of the function cannot be
-    /// found, this returns zeros for both values.
-    void getSourceLocation(unsigned &LineNo, unsigned &ColNo) const;
-  };
-
-
-  /// ProgramInfo - This object contains information about the loaded program.
-  /// When a new program is loaded, an instance of this class is created.  When
-  /// the program is unloaded, the instance is destroyed.  This object basically
-  /// manages the lazy computation of information useful for the debugger.
-  class ProgramInfo {
-    Module *M;
-
-    /// ProgramTimeStamp - This is the timestamp of the executable file that we
-    /// currently have loaded into the debugger.
-    sys::TimeValue ProgramTimeStamp;
-
-    /// SourceFiles - This map is used to transform source file descriptors into
-    /// their corresponding SourceFileInfo objects.  This mapping owns the
-    /// memory for the SourceFileInfo objects.
-    ///
-    bool SourceFilesIsComplete;
-    std::map<const GlobalVariable*, SourceFileInfo*> SourceFiles;
-
-    /// SourceFileIndex - Mapping from source file basenames to the information
-    /// about the file.  Note that there can be filename collisions, so this is
-    /// a multimap.  This map is populated incrementally as the user interacts
-    /// with the program, through the getSourceFileFromDesc method.  If ALL of
-    /// the source files are needed, the getSourceFiles() method scans the
-    /// entire program looking for them.
-    ///
-    std::multimap<std::string, SourceFileInfo*> SourceFileIndex;
-
-    /// SourceFunctions - This map contains entries functions in the source
-    /// program.  If SourceFunctionsIsComplete is true, then this is ALL of the
-    /// functions in the program are in this map.
-    bool SourceFunctionsIsComplete;
-    std::map<const GlobalVariable*, SourceFunctionInfo*> SourceFunctions;
-
-    /// LanguageCaches - Each source language is permitted to keep a per-program
-    /// cache of information specific to whatever it needs.  This vector is
-    /// effectively a small map from the languages that are active in the
-    /// program to their caches.  This can be accessed by the language by the
-    /// "getLanguageCache" method.
-    std::vector<std::pair<const SourceLanguage*,
-                          SourceLanguageCache*> > LanguageCaches;
-  public:
-    ProgramInfo(Module *m);
-    ~ProgramInfo();
-
-    /// getProgramTimeStamp - Return the time-stamp of the program when it was
-    /// loaded.
-    sys::TimeValue getProgramTimeStamp() const { return ProgramTimeStamp; }
-
-    //===------------------------------------------------------------------===//
-    // Interfaces to the source code files that make up the program.
-    //
-
-    /// getSourceFile - Return source file information for the specified source
-    /// file descriptor object, adding it to the collection as needed.  This
-    /// method always succeeds (is unambiguous), and is always efficient.
-    ///
-    const SourceFileInfo &getSourceFile(const GlobalVariable *Desc);
-
-    /// getSourceFile - Look up the file with the specified name.  If there is
-    /// more than one match for the specified filename, prompt the user to pick
-    /// one.  If there is no source file that matches the specified name, throw
-    /// an exception indicating that we can't find the file.  Otherwise, return
-    /// the file information for that file.
-    ///
-    /// If the source file hasn't been discovered yet in the program, this
-    /// method might have to index the whole program by calling the
-    /// getSourceFiles() method.
-    ///
-    const SourceFileInfo &getSourceFile(const std::string &Filename);
-
-    /// getSourceFiles - Index all of the source files in the program and return
-    /// them.  This information is lazily computed the first time that it is
-    /// requested.  Since this information can take a long time to compute, the
-    /// user is given a chance to cancel it.  If this occurs, an exception is
-    /// thrown.
-    const std::map<const GlobalVariable*, SourceFileInfo*> &
-    getSourceFiles(bool RequiresCompleteMap = true);
-
-    //===------------------------------------------------------------------===//
-    // Interfaces to the functions that make up the program.
-    //
-
-    /// getFunction - Return source function information for the specified
-    /// function descriptor object, adding it to the collection as needed.  This
-    /// method always succeeds (is unambiguous), and is always efficient.
-    ///
-    const SourceFunctionInfo &getFunction(const GlobalVariable *Desc);
-
-    /// getSourceFunctions - Index all of the functions in the program and
-    /// return them.  This information is lazily computed the first time that it
-    /// is requested.  Since this information can take a long time to compute,
-    /// the user is given a chance to cancel it.  If this occurs, an exception
-    /// is thrown.
-    const std::map<const GlobalVariable*, SourceFunctionInfo*> &
-    getSourceFunctions(bool RequiresCompleteMap = true);
-
-    /// addSourceFunctionsRead - Return true if the source functions map is
-    /// complete: that is, all functions in the program have been read in.
-    bool allSourceFunctionsRead() const { return SourceFunctionsIsComplete; }
-
-    /// getLanguageCache - This method is used to build per-program caches of
-    /// information, such as the functions or types visible to the program.
-    /// This can be used by SourceLanguage implementations because it requires
-    /// an accessible [sl]::CacheType typedef, where [sl] is the C++ type of the
-    /// source-language subclass.
-    template<typename SL>
-    typename SL::CacheType &getLanguageCache(const SL *L) {
-      for (unsigned i = 0, e = LanguageCaches.size(); i != e; ++i)
-        if (LanguageCaches[i].first == L)
-          return *(typename SL::CacheType*)LanguageCaches[i].second;
-      typename SL::CacheType *NewCache = L->createSourceLanguageCache(*this);
-      LanguageCaches.push_back(std::make_pair(L, NewCache));
-      return *NewCache;
-    }
-  };
-
-} // end namespace llvm
-
-#endif