mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 04:29:21 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21409 91177308-0d34-0410-b5e6-96231b3b80d8
247 lines
10 KiB
C++
247 lines
10 KiB
C++
//===- ProgramInfo.h - Information about the loaded program -----*- 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 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
|