llvm-6502/include/llvm/Debugger/ProgramInfo.h
Chris Lattner 7ed47a1335 Don't attribute in file headers anymore. See llvmdev for the
discussion of this change.  Boy are my fingers tired. ;-)



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45411 91177308-0d34-0410-b5e6-96231b3b80d8
2007-12-29 19:59:42 +00:00

247 lines
10 KiB
C++

//===- 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;
class 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