mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 21:29:20 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21409 91177308-0d34-0410-b5e6-96231b3b80d8
143 lines
5.1 KiB
C++
143 lines
5.1 KiB
C++
//===- RuntimeInfo.h - Information about running 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 classes that capture various pieces of information about
|
|
// the currently executing, but stopped, program. One instance of this object
|
|
// is created every time a program is stopped, and destroyed every time it
|
|
// starts running again. This object's main goal is to make access to runtime
|
|
// information easy and efficient, by caching information as requested.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_DEBUGGER_RUNTIMEINFO_H
|
|
#define LLVM_DEBUGGER_RUNTIMEINFO_H
|
|
|
|
#include <vector>
|
|
#include <cassert>
|
|
|
|
namespace llvm {
|
|
class ProgramInfo;
|
|
class RuntimeInfo;
|
|
class InferiorProcess;
|
|
class GlobalVariable;
|
|
class SourceFileInfo;
|
|
|
|
/// StackFrame - One instance of this structure is created for each stack
|
|
/// frame that is active in the program.
|
|
///
|
|
class StackFrame {
|
|
RuntimeInfo &RI;
|
|
void *FrameID;
|
|
const GlobalVariable *FunctionDesc;
|
|
|
|
/// LineNo, ColNo, FileInfo - This information indicates WHERE in the source
|
|
/// code for the program the stack frame is located.
|
|
unsigned LineNo, ColNo;
|
|
const SourceFileInfo *SourceInfo;
|
|
public:
|
|
StackFrame(RuntimeInfo &RI, void *ParentFrameID);
|
|
|
|
StackFrame &operator=(const StackFrame &RHS) {
|
|
FrameID = RHS.FrameID;
|
|
FunctionDesc = RHS.FunctionDesc;
|
|
return *this;
|
|
}
|
|
|
|
/// getFrameID - return the low-level opaque frame ID of this stack frame.
|
|
///
|
|
void *getFrameID() const { return FrameID; }
|
|
|
|
/// getFunctionDesc - Return the descriptor for the function that contains
|
|
/// this stack frame, or null if it is unknown.
|
|
///
|
|
const GlobalVariable *getFunctionDesc();
|
|
|
|
/// getSourceLocation - Return the source location that this stack frame is
|
|
/// sitting at.
|
|
void getSourceLocation(unsigned &LineNo, unsigned &ColNo,
|
|
const SourceFileInfo *&SourceInfo);
|
|
};
|
|
|
|
|
|
/// RuntimeInfo - This class collects information about the currently running
|
|
/// process. It is created whenever the program stops execution for the
|
|
/// debugger, and destroyed whenver execution continues.
|
|
class RuntimeInfo {
|
|
/// ProgInfo - This object contains static information about the program.
|
|
///
|
|
ProgramInfo *ProgInfo;
|
|
|
|
/// IP - This object contains information about the actual inferior process
|
|
/// that we are communicating with and aggregating information from.
|
|
const InferiorProcess &IP;
|
|
|
|
/// CallStack - This caches information about the current stack trace of the
|
|
/// program. This is lazily computed as needed.
|
|
std::vector<StackFrame> CallStack;
|
|
|
|
/// CurrentFrame - The user can traverse the stack frame with the
|
|
/// up/down/frame family of commands. This index indicates the current
|
|
/// stack frame.
|
|
unsigned CurrentFrame;
|
|
|
|
public:
|
|
RuntimeInfo(ProgramInfo *PI, const InferiorProcess &ip)
|
|
: ProgInfo(PI), IP(ip), CurrentFrame(0) {
|
|
// Make sure that the top of stack has been materialized. If this throws
|
|
// an exception, something is seriously wrong and the RuntimeInfo object
|
|
// would be unusable anyway.
|
|
getStackFrame(0);
|
|
}
|
|
|
|
ProgramInfo &getProgramInfo() { return *ProgInfo; }
|
|
const InferiorProcess &getInferiorProcess() const { return IP; }
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// Methods for inspecting the call stack of the program.
|
|
//
|
|
|
|
/// getStackFrame - Materialize the specified stack frame and return it. If
|
|
/// the specified ID is off of the bottom of the stack, throw an exception
|
|
/// indicating the problem.
|
|
StackFrame &getStackFrame(unsigned ID) {
|
|
if (ID >= CallStack.size())
|
|
materializeFrame(ID);
|
|
return CallStack[ID];
|
|
}
|
|
|
|
/// getCurrentFrame - Return the current stack frame object that the user is
|
|
/// inspecting.
|
|
StackFrame &getCurrentFrame() {
|
|
assert(CallStack.size() > CurrentFrame &&
|
|
"Must have materialized frame before making it current!");
|
|
return CallStack[CurrentFrame];
|
|
}
|
|
|
|
/// getCurrentFrameIdx - Return the current frame the user is inspecting.
|
|
///
|
|
unsigned getCurrentFrameIdx() const { return CurrentFrame; }
|
|
|
|
/// setCurrentFrameIdx - Set the current frame index to the specified value.
|
|
/// Note that the specified frame must have been materialized with
|
|
/// getStackFrame before it can be made current.
|
|
void setCurrentFrameIdx(unsigned Idx) {
|
|
assert(Idx < CallStack.size() &&
|
|
"Must materialize frame before making it current!");
|
|
CurrentFrame = Idx;
|
|
}
|
|
private:
|
|
/// materializeFrame - Create and process all frames up to and including the
|
|
/// specified frame number. This throws an exception if the specified frame
|
|
/// ID is nonexistant.
|
|
void materializeFrame(unsigned ID);
|
|
};
|
|
}
|
|
|
|
#endif
|