forked from OSchip/llvm-project
Initial checkin of the LLVM source-level debugger. This is still not finished,
by any stretch of the imagination, but it is pretty cool and works :) llvm-svn: 10685
This commit is contained in:
Chris Lattner
parent
67822803d0
commit
3bb92c65fd
|
|
@ -0,0 +1,212 @@
|
|||
//===-- Debugger.cpp - LLVM debugger library implementation ---------------===//
|
||||
//
|
||||
// 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 contains the main implementation of the LLVM debugger library.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/Debugger.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/ModuleProvider.h"
|
||||
#include "llvm/Bytecode/Reader.h"
|
||||
#include "llvm/Debugger/InferiorProcess.h"
|
||||
#include "Support/StringExtras.h"
|
||||
using namespace llvm;
|
||||
|
||||
/// Debugger constructor - Initialize the debugger to its initial, empty, state.
|
||||
///
|
||||
Debugger::Debugger() : Environment(0), Program(0), Process(0) {
|
||||
}
|
||||
|
||||
Debugger::~Debugger() {
|
||||
// Killing the program could throw an exception. We don't want to progagate
|
||||
// the exception out of our destructor though.
|
||||
try {
|
||||
killProgram();
|
||||
} catch (const char *) {
|
||||
} catch (const std::string &) {
|
||||
}
|
||||
|
||||
unloadProgram();
|
||||
}
|
||||
|
||||
/// getProgramPath - Get the path of the currently loaded program, or an
|
||||
/// empty string if none is loaded.
|
||||
std::string Debugger::getProgramPath() const {
|
||||
return Program ? Program->getModuleIdentifier() : "";
|
||||
}
|
||||
|
||||
static Module *
|
||||
getMaterializedModuleProvider(const std::string &Filename) {
|
||||
try {
|
||||
std::auto_ptr<ModuleProvider> Result(getBytecodeModuleProvider(Filename));
|
||||
if (!Result.get()) return 0;
|
||||
|
||||
Result->materializeModule();
|
||||
return Result.release()->releaseModule();
|
||||
} catch (...) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/// 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 Debugger::loadProgram(const std::string &Filename) {
|
||||
if ((Program = getMaterializedModuleProvider(Filename)) ||
|
||||
(Program = getMaterializedModuleProvider(Filename+".bc")))
|
||||
return; // Successfully loaded the program.
|
||||
|
||||
// Search the program path for the file...
|
||||
if (const char *PathS = getenv("PATH")) {
|
||||
std::string Path = PathS;
|
||||
|
||||
std::string Directory = getToken(Path, ":");
|
||||
while (!Directory.empty()) {
|
||||
if ((Program = getMaterializedModuleProvider(Directory +"/"+ Filename)) ||
|
||||
(Program = getMaterializedModuleProvider(Directory +"/"+ Filename
|
||||
+ ".bc")))
|
||||
return; // Successfully loaded the program.
|
||||
|
||||
Directory = getToken(Path, ":");
|
||||
}
|
||||
}
|
||||
|
||||
throw "Could not find program '" + Filename + "'!";
|
||||
}
|
||||
|
||||
/// 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 Debugger::unloadProgram() {
|
||||
if (!isProgramLoaded()) return;
|
||||
killProgram();
|
||||
delete Program;
|
||||
Program = 0;
|
||||
}
|
||||
|
||||
|
||||
/// 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 Debugger::createProgram() {
|
||||
if (!isProgramLoaded())
|
||||
throw "Cannot start program: none is loaded.";
|
||||
|
||||
// Kill any existing program.
|
||||
killProgram();
|
||||
|
||||
// Add argv[0] to the arguments vector..
|
||||
std::vector<std::string> Args(ProgramArguments);
|
||||
Args.insert(Args.begin(), getProgramPath());
|
||||
|
||||
// Start the new program... this could throw if the program cannot be started.
|
||||
Process = InferiorProcess::create(Program, Args, Environment);
|
||||
}
|
||||
|
||||
/// 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.
|
||||
void Debugger::killProgram() {
|
||||
// The destructor takes care of the dirty work.
|
||||
delete Process;
|
||||
Process = 0;
|
||||
}
|
||||
|
||||
/// stepProgram - Implement the 'step' command, continuing execution until
|
||||
/// the next possible stop point.
|
||||
void Debugger::stepProgram() {
|
||||
assert(isProgramRunning() && "Cannot step if the program isn't running!");
|
||||
try {
|
||||
Process->stepProgram();
|
||||
} catch (InferiorProcessDead &IPD) {
|
||||
delete Process;
|
||||
Process = 0;
|
||||
throw NonErrorException("The program stopped with exit code " +
|
||||
itostr(IPD.getExitCode()));
|
||||
}
|
||||
}
|
||||
|
||||
/// nextProgram - Implement the 'next' command, continuing execution until
|
||||
/// the next possible stop point that is in the current function.
|
||||
void Debugger::nextProgram() {
|
||||
assert(isProgramRunning() && "Cannot next if the program isn't running!");
|
||||
try {
|
||||
// This should step the process. If the process enters a function, then it
|
||||
// should 'finish' it. However, figuring this out is tricky. In
|
||||
// particular, the program can do any of:
|
||||
// 0. Not change current frame.
|
||||
// 1. Entering or exiting a region within the current function
|
||||
// (which changes the frame ID, but which we shouldn't 'finish')
|
||||
// 2. Exiting the current function (which changes the frame ID)
|
||||
// 3. Entering a function (which should be 'finish'ed)
|
||||
// For this reason, we have to be very careful about when we decide to do
|
||||
// the 'finish'.
|
||||
|
||||
// Get the current frame, but don't trust it. It could change...
|
||||
void *CurrentFrame = Process->getPreviousFrame(0);
|
||||
|
||||
// Don't trust the current frame: get the caller frame.
|
||||
void *ParentFrame = Process->getPreviousFrame(CurrentFrame);
|
||||
|
||||
// Ok, we have some information, run the program one step.
|
||||
Process->stepProgram();
|
||||
|
||||
// Where is the new frame? The most common case, by far is that it has not
|
||||
// been modified (Case #0), in which case we don't need to do anything more.
|
||||
void *NewFrame = Process->getPreviousFrame(0);
|
||||
if (NewFrame != CurrentFrame) {
|
||||
// Ok, the frame changed. If we are case #1, then the parent frame will
|
||||
// be identical.
|
||||
void *NewParentFrame = Process->getPreviousFrame(NewFrame);
|
||||
if (ParentFrame != NewParentFrame) {
|
||||
// Ok, now we know we aren't case #0 or #1. Check to see if we entered
|
||||
// a new function. If so, the parent frame will be "CurrentFrame".
|
||||
if (CurrentFrame == NewParentFrame)
|
||||
Process->finishProgram(NewFrame);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (InferiorProcessDead &IPD) {
|
||||
delete Process;
|
||||
Process = 0;
|
||||
throw NonErrorException("The program stopped with exit code " +
|
||||
itostr(IPD.getExitCode()));
|
||||
}
|
||||
}
|
||||
|
||||
/// finishProgram - Implement the 'finish' command, continuing execution
|
||||
/// until the specified frame ID returns.
|
||||
void Debugger::finishProgram(void *Frame) {
|
||||
assert(isProgramRunning() && "Cannot cont if the program isn't running!");
|
||||
try {
|
||||
Process->finishProgram(Frame);
|
||||
} catch (InferiorProcessDead &IPD) {
|
||||
delete Process;
|
||||
Process = 0;
|
||||
throw NonErrorException("The program stopped with exit code " +
|
||||
itostr(IPD.getExitCode()));
|
||||
}
|
||||
}
|
||||
|
||||
/// contProgram - Implement the 'cont' command, continuing execution until
|
||||
/// the next breakpoint is encountered.
|
||||
void Debugger::contProgram() {
|
||||
assert(isProgramRunning() && "Cannot cont if the program isn't running!");
|
||||
try {
|
||||
Process->contProgram();
|
||||
} catch (InferiorProcessDead &IPD) {
|
||||
delete Process;
|
||||
Process = 0;
|
||||
throw NonErrorException("The program stopped with exit code " +
|
||||
itostr(IPD.getExitCode()));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
##===- lib/Debugger/Makefile -------------------------------*- Makefile -*-===##
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
LEVEL = ../..
|
||||
LIBRARYNAME = debugger
|
||||
|
||||
include $(LEVEL)/Makefile.common
|
||||
|
|
@ -0,0 +1,409 @@
|
|||
//===-- ProgramInfo.cpp - Compute and cache info about a program ----------===//
|
||||
//
|
||||
// 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 implements the ProgramInfo and related classes, by sorting through
|
||||
// the loaded Module.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/ProgramInfo.h"
|
||||
#include "llvm/Constants.h"
|
||||
#include "llvm/DerivedTypes.h"
|
||||
#include "llvm/Intrinsics.h"
|
||||
#include "llvm/iOther.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/Debugger/SourceFile.h"
|
||||
#include "llvm/Debugger/SourceLanguage.h"
|
||||
#include "Support/FileUtilities.h"
|
||||
#include "Support/SlowOperationInformer.h"
|
||||
#include "Support/STLExtras.h"
|
||||
using namespace llvm;
|
||||
|
||||
/// getGlobalVariablesUsing - Return all of the global variables which have the
|
||||
/// specified value in their initializer somewhere.
|
||||
static void getGlobalVariablesUsing(Value *V,
|
||||
std::vector<GlobalVariable*> &Found) {
|
||||
for (Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) {
|
||||
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(*I))
|
||||
Found.push_back(GV);
|
||||
else if (Constant *C = dyn_cast<Constant>(*I))
|
||||
getGlobalVariablesUsing(C, Found);
|
||||
}
|
||||
}
|
||||
|
||||
/// getStringValue - Turn an LLVM constant pointer that eventually points to a
|
||||
/// global into a string value. Return an empty string if we can't do it.
|
||||
///
|
||||
static std::string getStringValue(Value *V, unsigned Offset = 0) {
|
||||
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
|
||||
if (GV->hasInitializer() && isa<ConstantArray>(GV->getInitializer())) {
|
||||
ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
|
||||
if (Init->getType()->getElementType() == Type::SByteTy ||
|
||||
Init->getType()->getElementType() == Type::UByteTy) {
|
||||
std::string Result = Init->getAsString();
|
||||
if (Offset < Result.size()) {
|
||||
// If we are pointing INTO The string, erase the beginning...
|
||||
Result.erase(Result.begin(), Result.begin()+Offset);
|
||||
|
||||
// Take off the null terminator, and any string fragments after it.
|
||||
std::string::size_type NullPos = Result.find_first_of((char)0);
|
||||
if (NullPos != std::string::npos)
|
||||
Result.erase(Result.begin()+NullPos, Result.end());
|
||||
return Result;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (Constant *C = dyn_cast<Constant>(V)) {
|
||||
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C))
|
||||
return getStringValue(CPR->getValue(), Offset);
|
||||
else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
|
||||
if (CE->getOpcode() == Instruction::GetElementPtr) {
|
||||
// Turn a gep into the specified offset.
|
||||
if (CE->getNumOperands() == 3 &&
|
||||
cast<Constant>(CE->getOperand(1))->isNullValue() &&
|
||||
isa<ConstantInt>(CE->getOperand(2))) {
|
||||
return getStringValue(CE->getOperand(0),
|
||||
Offset+cast<ConstantInt>(CE->getOperand(2))->getRawValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
/// getNextStopPoint - Follow the def-use chains of the specified LLVM value,
|
||||
/// traversing the use chains until we get to a stoppoint. When we do, return
|
||||
/// the source location of the stoppoint. If we don't find a stoppoint, return
|
||||
/// null.
|
||||
static const GlobalVariable *getNextStopPoint(const Value *V, unsigned &LineNo,
|
||||
unsigned &ColNo) {
|
||||
// The use-def chains can fork. As such, we pick the lowest numbered one we
|
||||
// find.
|
||||
const GlobalVariable *LastDesc = 0;
|
||||
unsigned LastLineNo = ~0;
|
||||
unsigned LastColNo = ~0;
|
||||
|
||||
for (Value::use_const_iterator UI = V->use_begin(), E = V->use_end();
|
||||
UI != E; ++UI) {
|
||||
bool ShouldRecurse = true;
|
||||
if (cast<Instruction>(*UI)->getOpcode() == Instruction::PHI) {
|
||||
// Infinite loops == bad, ignore PHI nodes.
|
||||
ShouldRecurse = false;
|
||||
} else if (const CallInst *CI = dyn_cast<CallInst>(*UI)) {
|
||||
// If we found a stop point, check to see if it is earlier than what we
|
||||
// already have. If so, remember it.
|
||||
if (const Function *F = CI->getCalledFunction())
|
||||
if (F->getIntrinsicID() == Intrinsic::dbg_stoppoint) {
|
||||
unsigned CurLineNo = ~0, CurColNo = ~0;
|
||||
const GlobalVariable *CurDesc = 0;
|
||||
if (const ConstantInt *C = dyn_cast<ConstantInt>(CI->getOperand(2)))
|
||||
CurLineNo = C->getRawValue();
|
||||
if (const ConstantInt *C = dyn_cast<ConstantInt>(CI->getOperand(3)))
|
||||
CurColNo = C->getRawValue();
|
||||
const Value *Op = CI->getOperand(4);
|
||||
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Op))
|
||||
Op = CPR->getValue();
|
||||
|
||||
if ((CurDesc = dyn_cast<GlobalVariable>(Op)) &&
|
||||
(LineNo < LastLineNo ||
|
||||
(LineNo == LastLineNo && ColNo < LastColNo))) {
|
||||
LastDesc = CurDesc;
|
||||
LastLineNo = CurLineNo;
|
||||
LastColNo = CurColNo;
|
||||
}
|
||||
ShouldRecurse = false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// If this is not a phi node or a stopping point, recursively scan the users
|
||||
// of this instruction to skip over region.begin's and the like.
|
||||
if (ShouldRecurse) {
|
||||
unsigned CurLineNo, CurColNo;
|
||||
if (const GlobalVariable *GV = getNextStopPoint(*UI, CurLineNo,CurColNo)){
|
||||
if (LineNo < LastLineNo || (LineNo == LastLineNo && ColNo < LastColNo)){
|
||||
LastDesc = GV;
|
||||
LastLineNo = CurLineNo;
|
||||
LastColNo = CurColNo;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (LastDesc) {
|
||||
LineNo = LastLineNo != ~0U ? LastLineNo : 0;
|
||||
ColNo = LastColNo != ~0U ? LastColNo : 0;
|
||||
}
|
||||
return LastDesc;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SourceFileInfo implementation
|
||||
//
|
||||
|
||||
SourceFileInfo::SourceFileInfo(const GlobalVariable *Desc,
|
||||
const SourceLanguage &Lang)
|
||||
: Language(&Lang), Descriptor(Desc) {
|
||||
Version = 0;
|
||||
SourceText = 0;
|
||||
|
||||
if (Desc && Desc->hasInitializer())
|
||||
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Desc->getInitializer()))
|
||||
if (CS->getNumOperands() > 4) {
|
||||
if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(CS->getOperand(1)))
|
||||
Version = CUI->getValue();
|
||||
|
||||
BaseName = getStringValue(CS->getOperand(3));
|
||||
Directory = getStringValue(CS->getOperand(4));
|
||||
}
|
||||
}
|
||||
|
||||
SourceFileInfo::~SourceFileInfo() {
|
||||
delete SourceText;
|
||||
}
|
||||
|
||||
SourceFile &SourceFileInfo::getSourceText() const {
|
||||
// FIXME: this should take into account the source search directories!
|
||||
if (SourceText == 0) // Read the file in if we haven't already.
|
||||
if (!Directory.empty() && FileOpenable(Directory+"/"+BaseName))
|
||||
SourceText = new SourceFile(Directory+"/"+BaseName, Descriptor);
|
||||
else
|
||||
SourceText = new SourceFile(BaseName, Descriptor);
|
||||
return *SourceText;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SourceFunctionInfo implementation
|
||||
//
|
||||
SourceFunctionInfo::SourceFunctionInfo(ProgramInfo &PI,
|
||||
const GlobalVariable *Desc)
|
||||
: Descriptor(Desc) {
|
||||
LineNo = ColNo = 0;
|
||||
if (Desc && Desc->hasInitializer())
|
||||
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Desc->getInitializer()))
|
||||
if (CS->getNumOperands() > 2) {
|
||||
// Entry #1 is the file descriptor.
|
||||
if (const ConstantPointerRef *CPR =
|
||||
dyn_cast<ConstantPointerRef>(CS->getOperand(1)))
|
||||
if (const GlobalVariable *GV =
|
||||
dyn_cast<GlobalVariable>(CPR->getValue()))
|
||||
SourceFile = &PI.getSourceFile(GV);
|
||||
|
||||
// Entry #2 is the function name.
|
||||
Name = getStringValue(CS->getOperand(2));
|
||||
}
|
||||
}
|
||||
|
||||
/// getSourceLocation - This method returns the location of the first stopping
|
||||
/// point in the function.
|
||||
void SourceFunctionInfo::getSourceLocation(unsigned &RetLineNo,
|
||||
unsigned &RetColNo) const {
|
||||
// If we haven't computed this yet...
|
||||
if (!LineNo) {
|
||||
// Look at all of the users of the function descriptor, looking for calls to
|
||||
// %llvm.dbg.func.start.
|
||||
for (Value::use_const_iterator UI = Descriptor->use_begin(),
|
||||
E = Descriptor->use_end(); UI != E; ++UI)
|
||||
if (const CallInst *CI = dyn_cast<CallInst>(*UI))
|
||||
if (const Function *F = CI->getCalledFunction())
|
||||
if (F->getIntrinsicID() == Intrinsic::dbg_func_start) {
|
||||
// We found the start of the function. Check to see if there are
|
||||
// any stop points on the use-list of the function start.
|
||||
const GlobalVariable *SD = getNextStopPoint(CI, LineNo, ColNo);
|
||||
if (SD) { // We found the first stop point!
|
||||
// This is just a sanity check.
|
||||
if (getSourceFile().getDescriptor() != SD)
|
||||
std::cout << "WARNING: first line of function is not in the"
|
||||
" file that the function descriptor claims it is in.\n";
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
RetLineNo = LineNo; RetColNo = ColNo;
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// ProgramInfo implementation
|
||||
//
|
||||
|
||||
ProgramInfo::ProgramInfo(Module *m) : M(m) {
|
||||
assert(M && "Cannot create program information with a null module!");
|
||||
ProgramTimeStamp = getFileTimestamp(M->getModuleIdentifier());
|
||||
|
||||
SourceFilesIsComplete = false;
|
||||
SourceFunctionsIsComplete = false;
|
||||
}
|
||||
|
||||
ProgramInfo::~ProgramInfo() {
|
||||
// Delete cached information about source program objects...
|
||||
for (std::map<const GlobalVariable*, SourceFileInfo*>::iterator
|
||||
I = SourceFiles.begin(), E = SourceFiles.end(); I != E; ++I)
|
||||
delete I->second;
|
||||
for (std::map<const GlobalVariable*, SourceFunctionInfo*>::iterator
|
||||
I = SourceFunctions.begin(), E = SourceFunctions.end(); I != E; ++I)
|
||||
delete I->second;
|
||||
|
||||
// Delete the source language caches.
|
||||
for (unsigned i = 0, e = LanguageCaches.size(); i != e; ++i)
|
||||
delete LanguageCaches[i].second;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SourceFileInfo tracking...
|
||||
//
|
||||
|
||||
/// 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 &
|
||||
ProgramInfo::getSourceFile(const GlobalVariable *Desc) {
|
||||
SourceFileInfo *&Result = SourceFiles[Desc];
|
||||
if (Result) return *Result;
|
||||
|
||||
// Figure out what language this source file comes from...
|
||||
unsigned LangID = 0; // Zero is unknown language
|
||||
if (Desc && Desc->hasInitializer())
|
||||
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Desc->getInitializer()))
|
||||
if (CS->getNumOperands() > 2)
|
||||
if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(CS->getOperand(2)))
|
||||
LangID = CUI->getValue();
|
||||
|
||||
const SourceLanguage &Lang = SourceLanguage::get(LangID);
|
||||
SourceFileInfo *New = Lang.createSourceFileInfo(Desc, *this);
|
||||
|
||||
// FIXME: this should check to see if there is already a Filename/WorkingDir
|
||||
// pair that matches this one. If so, we shouldn't create the duplicate!
|
||||
//
|
||||
SourceFileIndex.insert(std::make_pair(New->getBaseName(), New));
|
||||
return *(Result = New);
|
||||
}
|
||||
|
||||
|
||||
/// getSourceFiles - Index all of the source files in the program and return
|
||||
/// a mapping of it. 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*> &
|
||||
ProgramInfo::getSourceFiles(bool RequiresCompleteMap) {
|
||||
// If we have a fully populated map, or if the client doesn't need one, just
|
||||
// return what we have.
|
||||
if (SourceFilesIsComplete || !RequiresCompleteMap)
|
||||
return SourceFiles;
|
||||
|
||||
// Ok, all of the source file descriptors (compile_unit in dwarf terms),
|
||||
// should be on the use list of the llvm.dbg.translation_units global.
|
||||
//
|
||||
GlobalVariable *Units =
|
||||
M->getGlobalVariable("llvm.dbg.translation_units",
|
||||
StructType::get(std::vector<const Type*>()));
|
||||
if (Units == 0)
|
||||
throw "Program contains no debugging information!";
|
||||
|
||||
std::vector<GlobalVariable*> TranslationUnits;
|
||||
getGlobalVariablesUsing(Units, TranslationUnits);
|
||||
|
||||
SlowOperationInformer SOI("building source files index");
|
||||
|
||||
// Loop over all of the translation units found, building the SourceFiles
|
||||
// mapping.
|
||||
for (unsigned i = 0, e = TranslationUnits.size(); i != e; ++i) {
|
||||
getSourceFile(TranslationUnits[i]);
|
||||
SOI.progress(i+1, e);
|
||||
}
|
||||
|
||||
// Ok, if we got this far, then we indexed the whole program.
|
||||
SourceFilesIsComplete = true;
|
||||
return SourceFiles;
|
||||
}
|
||||
|
||||
/// 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.
|
||||
const SourceFileInfo &ProgramInfo::getSourceFile(const std::string &Filename) {
|
||||
std::multimap<std::string, SourceFileInfo*>::const_iterator Start, End;
|
||||
getSourceFiles();
|
||||
tie(Start, End) = SourceFileIndex.equal_range(Filename);
|
||||
|
||||
if (Start == End) throw "Could not find source file '" + Filename + "'!";
|
||||
const SourceFileInfo &SFI = *Start->second;
|
||||
++Start;
|
||||
if (Start == End) return SFI;
|
||||
|
||||
throw "FIXME: Multiple source files with the same name not implemented!";
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SourceFunctionInfo tracking...
|
||||
//
|
||||
|
||||
|
||||
/// getFunction - Return 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 &
|
||||
ProgramInfo::getFunction(const GlobalVariable *Desc) {
|
||||
SourceFunctionInfo *&Result = SourceFunctions[Desc];
|
||||
if (Result) return *Result;
|
||||
|
||||
// Figure out what language this function comes from...
|
||||
const GlobalVariable *SourceFileDesc = 0;
|
||||
if (Desc && Desc->hasInitializer())
|
||||
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Desc->getInitializer()))
|
||||
if (CS->getNumOperands() > 0)
|
||||
if (const ConstantPointerRef *CPR =
|
||||
dyn_cast<ConstantPointerRef>(CS->getOperand(1)))
|
||||
SourceFileDesc = dyn_cast<GlobalVariable>(CPR->getValue());
|
||||
|
||||
const SourceLanguage &Lang = getSourceFile(SourceFileDesc).getLanguage();
|
||||
return *(Result = Lang.createSourceFunctionInfo(Desc, *this));
|
||||
}
|
||||
|
||||
|
||||
// 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*> &
|
||||
ProgramInfo::getSourceFunctions(bool RequiresCompleteMap) {
|
||||
if (SourceFunctionsIsComplete || !RequiresCompleteMap)
|
||||
return SourceFunctions;
|
||||
|
||||
// Ok, all of the source function descriptors (subprogram in dwarf terms),
|
||||
// should be on the use list of the llvm.dbg.translation_units global.
|
||||
//
|
||||
GlobalVariable *Units =
|
||||
M->getGlobalVariable("llvm.dbg.globals",
|
||||
StructType::get(std::vector<const Type*>()));
|
||||
if (Units == 0)
|
||||
throw "Program contains no debugging information!";
|
||||
|
||||
std::vector<GlobalVariable*> Functions;
|
||||
getGlobalVariablesUsing(Units, Functions);
|
||||
|
||||
SlowOperationInformer SOI("building functions index");
|
||||
|
||||
// Loop over all of the functions found, building the SourceFunctions mapping.
|
||||
for (unsigned i = 0, e = Functions.size(); i != e; ++i) {
|
||||
getFunction(Functions[i]);
|
||||
SOI.progress(i+1, e);
|
||||
}
|
||||
|
||||
// Ok, if we got this far, then we indexed the whole program.
|
||||
SourceFunctionsIsComplete = true;
|
||||
return SourceFunctions;
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
//===-- llvm/lib/Debugger/ - LLVM Debugger interfaces ---------------------===//
|
||||
|
||||
This directory contains the implementation of the LLVM debugger backend. This
|
||||
directory builds into a library which can be used by various debugger
|
||||
front-ends to debug LLVM programs. The current command line LLVM debugger,
|
||||
llvm-db is currently the only client of this library, but others could be
|
||||
built, to provide a GUI front-end for example.
|
||||
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
//===-- RuntimeInfo.cpp - Compute and cache info about running program ----===//
|
||||
//
|
||||
// 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 implements the RuntimeInfo and related classes, by querying and
|
||||
// cachine information from the running inferior process.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/InferiorProcess.h"
|
||||
#include "llvm/Debugger/ProgramInfo.h"
|
||||
#include "llvm/Debugger/RuntimeInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// StackFrame class implementation
|
||||
|
||||
StackFrame::StackFrame(RuntimeInfo &ri, void *ParentFrameID)
|
||||
: RI(ri), SourceInfo(0) {
|
||||
FrameID = RI.getInferiorProcess().getPreviousFrame(ParentFrameID);
|
||||
if (FrameID == 0) throw "Stack frame does not exist!";
|
||||
|
||||
// Compute lazily as needed.
|
||||
FunctionDesc = 0;
|
||||
}
|
||||
|
||||
const GlobalVariable *StackFrame::getFunctionDesc() {
|
||||
if (FunctionDesc == 0)
|
||||
FunctionDesc = RI.getInferiorProcess().getSubprogramDesc(FrameID);
|
||||
return FunctionDesc;
|
||||
}
|
||||
|
||||
/// getSourceLocation - Return the source location that this stack frame is
|
||||
/// sitting at.
|
||||
void StackFrame::getSourceLocation(unsigned &lineNo, unsigned &colNo,
|
||||
const SourceFileInfo *&sourceInfo) {
|
||||
if (SourceInfo == 0) {
|
||||
const GlobalVariable *SourceDesc = 0;
|
||||
RI.getInferiorProcess().getFrameLocation(FrameID, LineNo,ColNo, SourceDesc);
|
||||
SourceInfo = &RI.getProgramInfo().getSourceFile(SourceDesc);
|
||||
}
|
||||
|
||||
lineNo = LineNo;
|
||||
colNo = ColNo;
|
||||
sourceInfo = SourceInfo;
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// RuntimeInfo class implementation
|
||||
|
||||
/// 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 RuntimeInfo::materializeFrame(unsigned ID) {
|
||||
assert(ID >= CallStack.size() && "no need to materialize this frame!");
|
||||
void *CurFrame = 0;
|
||||
if (!CallStack.empty())
|
||||
CurFrame = CallStack.back().getFrameID();
|
||||
|
||||
while (CallStack.size() <= ID) {
|
||||
CallStack.push_back(StackFrame(*this, CurFrame));
|
||||
CurFrame = CallStack.back().getFrameID();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
//===-- SourceFile.cpp - SourceFile implementation for the debugger -------===//
|
||||
//
|
||||
// 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 implements the SourceFile class for the LLVM debugger.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/SourceFile.h"
|
||||
#include "Support/SlowOperationInformer.h"
|
||||
#include "Support/FileUtilities.h"
|
||||
#include <iostream>
|
||||
#include <cerrno>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
using namespace llvm;
|
||||
|
||||
/// readFile - Load Filename into FileStart and FileEnd.
|
||||
///
|
||||
void SourceFile::readFile() {
|
||||
ssize_t FileSize = getFileSize(Filename);
|
||||
if (FileSize != -1) {
|
||||
FDHandle FD(open(Filename.c_str(), O_RDONLY));
|
||||
if (FD != -1) {
|
||||
char *FilePos = new char[FileSize];
|
||||
FileStart = FilePos;
|
||||
|
||||
// If this takes a long time, inform the user what we are doing.
|
||||
SlowOperationInformer SOI("loading source file '" + Filename + "'");
|
||||
|
||||
try {
|
||||
// Read in the whole buffer.
|
||||
unsigned Amount = FileSize;
|
||||
while (Amount) {
|
||||
unsigned AmountToRead = 512*1024;
|
||||
if (Amount < AmountToRead) AmountToRead = Amount;
|
||||
ssize_t ReadAmount = read(FD, FilePos, AmountToRead);
|
||||
if (ReadAmount < 0 && errno == EINTR)
|
||||
continue;
|
||||
else if (ReadAmount <= 0) {
|
||||
// Couldn't read whole file just free memory and continue.
|
||||
throw "Error reading file '" + Filename + "'!";
|
||||
}
|
||||
Amount -= ReadAmount;
|
||||
FilePos += ReadAmount;
|
||||
|
||||
SOI.progress(FileSize-Amount, FileSize);
|
||||
}
|
||||
|
||||
} catch (const std::string &Msg) {
|
||||
std::cout << Msg << "\n";
|
||||
// If the user cancels the operation, clean up after ourselves.
|
||||
delete [] FileStart;
|
||||
FileStart = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
FileEnd = FileStart+FileSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// calculateLineOffsets - Compute the LineOffset vector for the current file.
|
||||
///
|
||||
void SourceFile::calculateLineOffsets() const {
|
||||
assert(LineOffset.empty() && "Line offsets already computed!");
|
||||
const char *BufPtr = FileStart;
|
||||
do {
|
||||
LineOffset.push_back(BufPtr-FileStart);
|
||||
|
||||
// Scan until we get to a newline.
|
||||
while (BufPtr != FileEnd && *BufPtr != '\n' && *BufPtr != '\r')
|
||||
++BufPtr;
|
||||
|
||||
if (BufPtr != FileEnd) {
|
||||
++BufPtr; // Skip over the \n or \r
|
||||
if (BufPtr[-1] == '\r' && BufPtr != FileEnd && BufPtr[0] == '\n')
|
||||
++BufPtr; // Skip over dos/windows style \r\n's
|
||||
}
|
||||
} while (BufPtr != FileEnd);
|
||||
}
|
||||
|
||||
|
||||
/// getSourceLine - Given a line number, return the start and end of the line
|
||||
/// in the file. If the line number is invalid, or if the file could not be
|
||||
/// loaded, null pointers are returned for the start and end of the file. Note
|
||||
/// that line numbers start with 0, not 1.
|
||||
void SourceFile::getSourceLine(unsigned LineNo, const char *&LineStart,
|
||||
const char *&LineEnd) const {
|
||||
LineStart = LineEnd = 0;
|
||||
if (FileStart == 0) return; // Couldn't load file, return null pointers
|
||||
if (LineOffset.empty()) calculateLineOffsets();
|
||||
|
||||
// Asking for an out-of-range line number?
|
||||
if (LineNo >= LineOffset.size()) return;
|
||||
|
||||
// Otherwise, they are asking for a valid line, which we can fulfill.
|
||||
LineStart = FileStart+LineOffset[LineNo];
|
||||
|
||||
if (LineNo+1 < LineOffset.size())
|
||||
LineEnd = FileStart+LineOffset[LineNo+1];
|
||||
else
|
||||
LineEnd = FileEnd;
|
||||
|
||||
// If the line ended with a newline, strip it off.
|
||||
while (LineEnd != LineStart && (LineEnd[-1] == '\n' || LineEnd[-1] == '\r'))
|
||||
--LineEnd;
|
||||
|
||||
assert(LineEnd >= LineStart && "We somehow got our pointers swizzled!");
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
//===-- SourceLanguage-CFamily.cpp - C family SourceLanguage impl ---------===//
|
||||
//
|
||||
// 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 implements the SourceLanguage class for the C family of languages
|
||||
// (K&R C, C89, C99, etc).
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/SourceLanguage.h"
|
||||
using namespace llvm;
|
||||
|
||||
#if 0
|
||||
namespace {
|
||||
struct CSL : public SourceLanguage {
|
||||
} TheCSourceLanguageInstance;
|
||||
}
|
||||
#endif
|
||||
|
||||
const SourceLanguage &SourceLanguage::getCFamilyInstance() {
|
||||
return get(0); // We don't have an implementation for C yet fall back on
|
||||
// generic
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
//===-- SourceLanguage-CPlusPlus.cpp - C++ SourceLanguage impl ------------===//
|
||||
//
|
||||
// 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 implements the SourceLanguage class for the C++ language.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/SourceLanguage.h"
|
||||
using namespace llvm;
|
||||
|
||||
#if 0
|
||||
namespace {
|
||||
struct CPPSL : public SourceLanguage {
|
||||
} TheCPlusPlusLanguageInstance;
|
||||
}
|
||||
#endif
|
||||
|
||||
const SourceLanguage &SourceLanguage::getCPlusPlusInstance() {
|
||||
return get(0); // We don't have an implementation for C yet fall back on
|
||||
// generic
|
||||
}
|
||||
|
|
@ -0,0 +1,136 @@
|
|||
//===-- SourceLanguage-Unknown.cpp - Implement itf for unknown languages --===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// If the LLVM debugger does not have a module for a particular language, it
|
||||
// falls back on using this one to perform the source-language interface. This
|
||||
// interface is not wonderful, but it gets the job done.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/SourceLanguage.h"
|
||||
#include "llvm/Debugger/ProgramInfo.h"
|
||||
#include <iostream>
|
||||
using namespace llvm;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Implement the SourceLanguage cache for the Unknown language.
|
||||
//
|
||||
|
||||
namespace {
|
||||
/// SLUCache - This cache allows for efficient lookup of source functions by
|
||||
/// name.
|
||||
///
|
||||
struct SLUCache : public SourceLanguageCache {
|
||||
ProgramInfo &PI;
|
||||
std::multimap<std::string, SourceFunctionInfo*> FunctionMap;
|
||||
public:
|
||||
SLUCache(ProgramInfo &pi);
|
||||
|
||||
typedef std::multimap<std::string, SourceFunctionInfo*>::const_iterator
|
||||
fm_iterator;
|
||||
|
||||
std::pair<fm_iterator, fm_iterator>
|
||||
getFunction(const std::string &Name) const {
|
||||
return FunctionMap.equal_range(Name);
|
||||
}
|
||||
|
||||
SourceFunctionInfo *addSourceFunction(SourceFunctionInfo *SF) {
|
||||
FunctionMap.insert(std::make_pair(SF->getSymbolicName(), SF));
|
||||
return SF;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
SLUCache::SLUCache(ProgramInfo &pi) : PI(pi) {
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Implement SourceLanguageUnknown class, which is used to handle unrecognized
|
||||
// languages.
|
||||
//
|
||||
|
||||
namespace {
|
||||
struct SLU : public SourceLanguage {
|
||||
//===------------------------------------------------------------------===//
|
||||
// Implement the miscellaneous methods...
|
||||
//
|
||||
virtual const char *getSourceLanguageName() const {
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
/// lookupFunction - Given a textual function name, return the
|
||||
/// SourceFunctionInfo descriptor for that function, or null if it cannot be
|
||||
/// found. If the program is currently running, the RuntimeInfo object
|
||||
/// provides information about the current evaluation context, otherwise it
|
||||
/// will be null.
|
||||
///
|
||||
virtual SourceFunctionInfo *lookupFunction(const std::string &FunctionName,
|
||||
ProgramInfo &PI,
|
||||
RuntimeInfo *RI = 0) const;
|
||||
|
||||
//===------------------------------------------------------------------===//
|
||||
// We do use a cache for information...
|
||||
//
|
||||
typedef SLUCache CacheType;
|
||||
SLUCache *createSourceLanguageCache(ProgramInfo &PI) const {
|
||||
return new SLUCache(PI);
|
||||
}
|
||||
|
||||
/// createSourceFunctionInfo - Create the new object and inform the cache of
|
||||
/// the new function.
|
||||
virtual SourceFunctionInfo *
|
||||
createSourceFunctionInfo(const GlobalVariable *Desc, ProgramInfo &PI) const;
|
||||
|
||||
} TheUnknownSourceLanguageInstance;
|
||||
}
|
||||
|
||||
const SourceLanguage &SourceLanguage::getUnknownLanguageInstance() {
|
||||
return TheUnknownSourceLanguageInstance;
|
||||
}
|
||||
|
||||
|
||||
SourceFunctionInfo *
|
||||
SLU::createSourceFunctionInfo(const GlobalVariable *Desc,
|
||||
ProgramInfo &PI) const {
|
||||
SourceFunctionInfo *Result = new SourceFunctionInfo(PI, Desc);
|
||||
return PI.getLanguageCache(this).addSourceFunction(Result);
|
||||
}
|
||||
|
||||
|
||||
/// lookupFunction - Given a textual function name, return the
|
||||
/// SourceFunctionInfo descriptor for that function, or null if it cannot be
|
||||
/// found. If the program is currently running, the RuntimeInfo object
|
||||
/// provides information about the current evaluation context, otherwise it will
|
||||
/// be null.
|
||||
///
|
||||
SourceFunctionInfo *SLU::lookupFunction(const std::string &FunctionName,
|
||||
ProgramInfo &PI, RuntimeInfo *RI) const{
|
||||
SLUCache &Cache = PI.getLanguageCache(this);
|
||||
std::pair<SLUCache::fm_iterator, SLUCache::fm_iterator> IP
|
||||
= Cache.getFunction(FunctionName);
|
||||
|
||||
if (IP.first == IP.second) {
|
||||
if (PI.allSourceFunctionsRead())
|
||||
return 0; // Nothing found
|
||||
|
||||
// Otherwise, we might be able to find the function if we read all of them
|
||||
// in. Do so now.
|
||||
PI.getSourceFunctions();
|
||||
assert(PI.allSourceFunctionsRead() && "Didn't read in all functions?");
|
||||
return lookupFunction(FunctionName, PI, RI);
|
||||
}
|
||||
|
||||
SourceFunctionInfo *Found = IP.first->second;
|
||||
++IP.first;
|
||||
if (IP.first != IP.second)
|
||||
std::cout << "Whoa, found multiple functions with the same name. I should"
|
||||
<< " ask the user which one to use: FIXME!\n";
|
||||
return Found;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
//===-- SourceLanguage.cpp - Implement the SourceLanguage class -----------===//
|
||||
//
|
||||
// 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 implements the SourceLanguage class.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/SourceLanguage.h"
|
||||
#include "llvm/Debugger/ProgramInfo.h"
|
||||
using namespace llvm;
|
||||
|
||||
const SourceLanguage &SourceLanguage::get(unsigned ID) {
|
||||
switch (ID) {
|
||||
case 1: // DW_LANG_C89
|
||||
case 2: // DW_LANG_C
|
||||
case 12: // DW_LANG_C99
|
||||
return getCFamilyInstance();
|
||||
|
||||
case 4: // DW_LANG_C_plus_plus
|
||||
return getCPlusPlusInstance();
|
||||
|
||||
case 3: // DW_LANG_Ada83
|
||||
case 5: // DW_LANG_Cobol74
|
||||
case 6: // DW_LANG_Cobol85
|
||||
case 7: // DW_LANG_Fortran77
|
||||
case 8: // DW_LANG_Fortran90
|
||||
case 9: // DW_LANG_Pascal83
|
||||
case 10: // DW_LANG_Modula2
|
||||
case 11: // DW_LANG_Java
|
||||
case 13: // DW_LANG_Ada95
|
||||
case 14: // DW_LANG_Fortran95
|
||||
default:
|
||||
return getUnknownLanguageInstance();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SourceFileInfo *
|
||||
SourceLanguage::createSourceFileInfo(const GlobalVariable *Desc,
|
||||
ProgramInfo &PI) const {
|
||||
return new SourceFileInfo(Desc, *this);
|
||||
}
|
||||
|
||||
SourceFunctionInfo *
|
||||
SourceLanguage::createSourceFunctionInfo(const GlobalVariable *Desc,
|
||||
ProgramInfo &PI) const {
|
||||
return new SourceFunctionInfo(PI, Desc);
|
||||
}
|
||||
|
|
@ -0,0 +1,911 @@
|
|||
//===-- UnixLocalInferiorProcess.cpp - A Local process on a Unixy system --===//
|
||||
//
|
||||
// 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 provides one implementation of the InferiorProcess class, which is
|
||||
// designed to be used on unixy systems (those that support pipe, fork, exec,
|
||||
// and signals).
|
||||
//
|
||||
// When the process is started, the debugger creates a pair of pipes, forks, and
|
||||
// makes the child starts executing the program. The child executes the process
|
||||
// with an IntrinsicLowering instance that turns debugger intrinsics into actual
|
||||
// callbacks.
|
||||
//
|
||||
// This target takes advantage of the fact that the Module* addresses in the
|
||||
// parent and the Module* addresses in the child will be the same, due to the
|
||||
// use of fork(). As such, global addresses looked up in the child can be sent
|
||||
// over the pipe to the debugger.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Debugger/InferiorProcess.h"
|
||||
#include "llvm/IntrinsicLowering.h"
|
||||
#include "llvm/Constant.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/ModuleProvider.h"
|
||||
#include "llvm/Type.h"
|
||||
#include "llvm/iOther.h"
|
||||
#include "llvm/ExecutionEngine/GenericValue.h"
|
||||
#include "llvm/ExecutionEngine/ExecutionEngine.h"
|
||||
#include "Support/FileUtilities.h"
|
||||
#include "Support/StringExtras.h"
|
||||
#include <cerrno>
|
||||
#include <unistd.h> // Unix specific debugger support
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
using namespace llvm;
|
||||
|
||||
// runChild - Entry point for the child process.
|
||||
static void runChild(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp,
|
||||
FDHandle ReadFD, FDHandle WriteFD);
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Parent/Child Pipe Protocol
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// The parent/child communication protocol is designed to have the child process
|
||||
// responding to requests that the debugger makes. Whenever the child process
|
||||
// has stopped (due to a break point, single stepping, etc), the child process
|
||||
// enters a message processing loop, where it reads and responds to commands
|
||||
// until the parent decides that it wants to continue execution in some way.
|
||||
//
|
||||
// Whenever the child process stops, it notifies the debugger by sending an
|
||||
// character over the wire.
|
||||
//
|
||||
|
||||
namespace {
|
||||
/// LocationToken - Objects of this type are sent across the pipe from the
|
||||
/// child to the parent to indicate where various stack frames are located.
|
||||
struct LocationToken {
|
||||
unsigned Line, Col;
|
||||
const GlobalVariable *File;
|
||||
LocationToken(unsigned L = 0, unsigned C = 0, const GlobalVariable *F = 0)
|
||||
: Line(L), Col(C), File(F) {}
|
||||
};
|
||||
}
|
||||
|
||||
// Once the debugger process has received the LocationToken, it can make
|
||||
// requests of the child by sending one of the following enum values followed by
|
||||
// any data required by that command. The child responds with data appropriate
|
||||
// to the command.
|
||||
//
|
||||
namespace {
|
||||
/// CommandID - This enum defines all of the commands that the child process
|
||||
/// can respond to. The actual expected data and responses are defined as the
|
||||
/// enum values are defined.
|
||||
///
|
||||
enum CommandID {
|
||||
//===------------------------------------------------------------------===//
|
||||
// Execution commands - These are sent to the child to from the debugger to
|
||||
// get it to do certain things.
|
||||
//
|
||||
|
||||
// StepProgram: void->char - This command causes the program to continue
|
||||
// execution, but stop as soon as it reaches another stoppoint.
|
||||
StepProgram,
|
||||
|
||||
// FinishProgram: FrameDesc*->char - This command causes the program to
|
||||
// continue execution until the specified function frame returns.
|
||||
FinishProgram,
|
||||
|
||||
// ContProgram: void->char - This command causes the program to continue
|
||||
// execution, stopping at some point in the future.
|
||||
ContProgram,
|
||||
|
||||
// GetSubprogramDescriptor: FrameDesc*->GlobalValue* - This command returns
|
||||
// the GlobalValue* descriptor object for the specified stack frame.
|
||||
GetSubprogramDescriptor,
|
||||
|
||||
// GetParentFrame: FrameDesc*->FrameDesc* - This command returns the frame
|
||||
// descriptor for the parent stack frame to the specified one, or null if
|
||||
// there is none.
|
||||
GetParentFrame,
|
||||
|
||||
// GetFrameLocation - FrameDesc*->LocationToken - This command returns the
|
||||
// location that a particular stack frame is stopped at.
|
||||
GetFrameLocation,
|
||||
|
||||
// AddBreakpoint - LocationToken->unsigned - This command instructs the
|
||||
// target to install a breakpoint at the specified location.
|
||||
AddBreakpoint,
|
||||
|
||||
// RemoveBreakpoint - unsigned->void - This command instructs the target to
|
||||
// remove a breakpoint.
|
||||
RemoveBreakpoint,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Parent Process Code
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
namespace {
|
||||
class IP : public InferiorProcess {
|
||||
// ReadFD, WriteFD - The file descriptors to read/write to the inferior
|
||||
// process.
|
||||
FDHandle ReadFD, WriteFD;
|
||||
|
||||
// ChildPID - The unix PID of the child process we forked.
|
||||
mutable pid_t ChildPID;
|
||||
public:
|
||||
IP(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp);
|
||||
~IP();
|
||||
|
||||
std::string getStatus() const;
|
||||
|
||||
/// Execution method implementations...
|
||||
virtual void stepProgram();
|
||||
virtual void finishProgram(void *Frame);
|
||||
virtual void contProgram();
|
||||
|
||||
|
||||
// Stack frame method implementations...
|
||||
virtual void *getPreviousFrame(void *Frame) const;
|
||||
virtual const GlobalVariable *getSubprogramDesc(void *Frame) const;
|
||||
virtual void getFrameLocation(void *Frame, unsigned &LineNo,
|
||||
unsigned &ColNo,
|
||||
const GlobalVariable *&SourceDesc) const;
|
||||
|
||||
// Breakpoint implementation methods
|
||||
virtual unsigned addBreakpoint(unsigned LineNo, unsigned ColNo,
|
||||
const GlobalVariable *SourceDesc);
|
||||
virtual void removeBreakpoint(unsigned ID);
|
||||
|
||||
|
||||
private:
|
||||
/// startChild - This starts up the child process, and initializes the
|
||||
/// ChildPID member.
|
||||
///
|
||||
void startChild(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp);
|
||||
|
||||
/// killChild - Kill or reap the child process. This throws the
|
||||
/// InferiorProcessDead exception an exit code if the process had already
|
||||
/// died, otherwise it just kills it and returns.
|
||||
void killChild() const;
|
||||
|
||||
private:
|
||||
// Methods for communicating with the child process. If the child exits or
|
||||
// dies while attempting to communicate with it, ChildPID is set to zero and
|
||||
// an exception is thrown.
|
||||
|
||||
/// readFromChild - Low-level primitive to read some data from the child,
|
||||
/// throwing an exception if it dies.
|
||||
void readFromChild(void *Buffer, unsigned Size) const;
|
||||
|
||||
/// writeToChild - Low-level primitive to send some data to the child
|
||||
/// process, throwing an exception if the child died.
|
||||
void writeToChild(void *Buffer, unsigned Size) const;
|
||||
|
||||
/// sendCommand - Send a command token and the request data to the child.
|
||||
///
|
||||
void sendCommand(CommandID Command, void *Data, unsigned Size) const;
|
||||
|
||||
/// waitForStop - This method waits for the child process to reach a stop
|
||||
/// point.
|
||||
void waitForStop();
|
||||
};
|
||||
}
|
||||
|
||||
// create - This is the factory method for the InferiorProcess class. Since
|
||||
// there is currently only one subclass of InferiorProcess, we just define it
|
||||
// here.
|
||||
InferiorProcess *
|
||||
InferiorProcess::create(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp) {
|
||||
return new IP(M, Arguments, envp);
|
||||
}
|
||||
|
||||
/// IP constructor - Create some pipes, them fork a child process. The child
|
||||
/// process should start execution of the debugged program, but stop at the
|
||||
/// first available opportunity.
|
||||
IP::IP(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp)
|
||||
: InferiorProcess(M) {
|
||||
|
||||
// Start the child running...
|
||||
startChild(M, Arguments, envp);
|
||||
|
||||
// Okay, we created the program and it is off and running. Wait for it to
|
||||
// stop now.
|
||||
try {
|
||||
waitForStop();
|
||||
} catch (InferiorProcessDead &IPD) {
|
||||
throw "Error waiting for the child process to stop. "
|
||||
"It exited with status " + itostr(IPD.getExitCode());
|
||||
}
|
||||
}
|
||||
|
||||
IP::~IP() {
|
||||
// If the child is still running, kill it.
|
||||
if (!ChildPID) return;
|
||||
|
||||
killChild();
|
||||
}
|
||||
|
||||
/// getStatus - Return information about the unix process being debugged.
|
||||
///
|
||||
std::string IP::getStatus() const {
|
||||
if (ChildPID == 0)
|
||||
return "Unix target. ERROR: child process appears to be dead!\n";
|
||||
|
||||
return "Unix target: PID #" + utostr((unsigned)ChildPID) + "\n";
|
||||
}
|
||||
|
||||
|
||||
/// startChild - This starts up the child process, and initializes the
|
||||
/// ChildPID member.
|
||||
///
|
||||
void IP::startChild(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp) {
|
||||
// Create the pipes. Make sure to immediately assign the returned file
|
||||
// descriptors to FDHandle's so they get destroyed if an exception is thrown.
|
||||
int FDs[2];
|
||||
if (pipe(FDs)) throw "Error creating a pipe!";
|
||||
FDHandle ChildReadFD(FDs[0]);
|
||||
WriteFD = FDs[1];
|
||||
|
||||
if (pipe(FDs)) throw "Error creating a pipe!";
|
||||
ReadFD = FDs[0];
|
||||
FDHandle ChildWriteFD(FDs[1]);
|
||||
|
||||
// Fork off the child process.
|
||||
switch (ChildPID = fork()) {
|
||||
case -1: throw "Error forking child process!";
|
||||
case 0: // child
|
||||
delete this; // Free parent pipe file descriptors
|
||||
runChild(M, Arguments, envp, ChildReadFD, ChildWriteFD);
|
||||
exit(1);
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
/// sendCommand - Send a command token and the request data to the child.
|
||||
///
|
||||
void IP::sendCommand(CommandID Command, void *Data, unsigned Size) const {
|
||||
writeToChild(&Command, sizeof(Command));
|
||||
writeToChild(Data, Size);
|
||||
}
|
||||
|
||||
/// stepProgram - Implement the 'step' command, continuing execution until
|
||||
/// the next possible stop point.
|
||||
void IP::stepProgram() {
|
||||
sendCommand(StepProgram, 0, 0);
|
||||
waitForStop();
|
||||
}
|
||||
|
||||
/// finishProgram - Implement the 'finish' command, executing the program until
|
||||
/// the current function returns to its caller.
|
||||
void IP::finishProgram(void *Frame) {
|
||||
sendCommand(FinishProgram, &Frame, sizeof(Frame));
|
||||
waitForStop();
|
||||
}
|
||||
|
||||
/// contProgram - Implement the 'cont' command, continuing execution until
|
||||
/// a breakpoint is encountered.
|
||||
void IP::contProgram() {
|
||||
sendCommand(ContProgram, 0, 0);
|
||||
waitForStop();
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Stack manipulation methods
|
||||
//
|
||||
|
||||
/// getPreviousFrame - Given the descriptor for the current stack frame,
|
||||
/// return the descriptor for the caller frame. This returns null when it
|
||||
/// runs out of frames.
|
||||
void *IP::getPreviousFrame(void *Frame) const {
|
||||
sendCommand(GetParentFrame, &Frame, sizeof(Frame));
|
||||
readFromChild(&Frame, sizeof(Frame));
|
||||
return Frame;
|
||||
}
|
||||
|
||||
/// getSubprogramDesc - Return the subprogram descriptor for the current
|
||||
/// stack frame.
|
||||
const GlobalVariable *IP::getSubprogramDesc(void *Frame) const {
|
||||
sendCommand(GetSubprogramDescriptor, &Frame, sizeof(Frame));
|
||||
const GlobalVariable *Desc;
|
||||
readFromChild(&Desc, sizeof(Desc));
|
||||
return Desc;
|
||||
}
|
||||
|
||||
/// getFrameLocation - This method returns the source location where each stack
|
||||
/// frame is stopped.
|
||||
void IP::getFrameLocation(void *Frame, unsigned &LineNo, unsigned &ColNo,
|
||||
const GlobalVariable *&SourceDesc) const {
|
||||
sendCommand(GetFrameLocation, &Frame, sizeof(Frame));
|
||||
LocationToken Loc;
|
||||
readFromChild(&Loc, sizeof(Loc));
|
||||
LineNo = Loc.Line;
|
||||
ColNo = Loc.Col;
|
||||
SourceDesc = Loc.File;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Breakpoint manipulation methods
|
||||
//
|
||||
unsigned IP::addBreakpoint(unsigned LineNo, unsigned ColNo,
|
||||
const GlobalVariable *SourceDesc) {
|
||||
LocationToken Loc;
|
||||
Loc.Line = LineNo;
|
||||
Loc.Col = ColNo;
|
||||
Loc.File = SourceDesc;
|
||||
sendCommand(AddBreakpoint, &Loc, sizeof(Loc));
|
||||
unsigned ID;
|
||||
readFromChild(&ID, sizeof(ID));
|
||||
return ID;
|
||||
}
|
||||
|
||||
void IP::removeBreakpoint(unsigned ID) {
|
||||
sendCommand(RemoveBreakpoint, &ID, sizeof(ID));
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Methods for communication with the child process
|
||||
//
|
||||
// Methods for communicating with the child process. If the child exits or dies
|
||||
// while attempting to communicate with it, ChildPID is set to zero and an
|
||||
// exception is thrown.
|
||||
//
|
||||
|
||||
/// readFromChild - Low-level primitive to read some data from the child,
|
||||
/// throwing an exception if it dies.
|
||||
void IP::readFromChild(void *Buffer, unsigned Size) const {
|
||||
assert(ChildPID &&
|
||||
"Child process died and still attempting to communicate with it!");
|
||||
while (Size) {
|
||||
ssize_t Amount = read(ReadFD, Buffer, Size);
|
||||
if (Amount == 0) {
|
||||
// If we cannot communicate with the process, kill it.
|
||||
killChild();
|
||||
// If killChild succeeded, then the process must have closed the pipe FD
|
||||
// or something, because the child existed, but we cannot communicate with
|
||||
// it.
|
||||
throw InferiorProcessDead(-1);
|
||||
} else if (Amount == -1) {
|
||||
if (errno != EINTR) {
|
||||
ChildPID = 0;
|
||||
killChild();
|
||||
throw "Error reading from child process!";
|
||||
}
|
||||
} else {
|
||||
// We read a chunk.
|
||||
Buffer = (char*)Buffer + Amount;
|
||||
Size -= Amount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// writeToChild - Low-level primitive to send some data to the child
|
||||
/// process, throwing an exception if the child died.
|
||||
void IP::writeToChild(void *Buffer, unsigned Size) const {
|
||||
while (Size) {
|
||||
ssize_t Amount = write(WriteFD, Buffer, Size);
|
||||
if (Amount < 0 && errno == EINTR) continue;
|
||||
if (Amount <= 0) {
|
||||
// If we cannot communicate with the process, kill it.
|
||||
killChild();
|
||||
|
||||
// If killChild succeeded, then the process must have closed the pipe FD
|
||||
// or something, because the child existed, but we cannot communicate with
|
||||
// it.
|
||||
throw InferiorProcessDead(-1);
|
||||
} else {
|
||||
// We wrote a chunk.
|
||||
Buffer = (char*)Buffer + Amount;
|
||||
Size -= Amount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// killChild - Kill or reap the child process. This throws the
|
||||
/// InferiorProcessDead exception an exit code if the process had already
|
||||
/// died, otherwise it just returns the exit code if it had to be killed.
|
||||
void IP::killChild() const {
|
||||
assert(ChildPID != 0 && "Child has already been reaped!");
|
||||
|
||||
int Status = 0;
|
||||
int PID;
|
||||
do {
|
||||
PID = waitpid(ChildPID, &Status, WNOHANG);
|
||||
} while (PID < 0 && errno == EINTR);
|
||||
if (PID < 0) throw "Error waiting for child to exit!";
|
||||
|
||||
// If the child process was already dead, then it died unexpectedly.
|
||||
if (PID) {
|
||||
assert(PID == ChildPID && "Didn't reap child?");
|
||||
ChildPID = 0; // Child has been reaped
|
||||
if (WIFEXITED(Status))
|
||||
throw InferiorProcessDead(WEXITSTATUS(Status));
|
||||
else if (WIFSIGNALED(Status))
|
||||
throw InferiorProcessDead(WTERMSIG(Status));
|
||||
throw InferiorProcessDead(-1);
|
||||
}
|
||||
|
||||
// Otherwise, the child exists and has not yet been killed.
|
||||
if (kill(ChildPID, SIGKILL) < 0)
|
||||
throw "Error killing child process!";
|
||||
|
||||
do {
|
||||
PID = waitpid(ChildPID, 0, 0);
|
||||
} while (PID < 0 && errno == EINTR);
|
||||
if (PID <= 0) throw "Error waiting for child to exit!";
|
||||
|
||||
assert(PID == ChildPID && "Didn't reap child?");
|
||||
}
|
||||
|
||||
|
||||
/// waitForStop - This method waits for the child process to reach a stop
|
||||
/// point. When it does, it fills in the CurLocation member and returns.
|
||||
void IP::waitForStop() {
|
||||
char Dummy;
|
||||
readFromChild(&Dummy, sizeof(char));
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Child Process Code
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
namespace {
|
||||
class SourceSubprogram;
|
||||
|
||||
/// SourceRegion - Instances of this class represent the regions that are
|
||||
/// active in the program.
|
||||
class SourceRegion {
|
||||
/// Parent - A pointer to the region that encloses the current one.
|
||||
SourceRegion *Parent;
|
||||
|
||||
/// CurSubprogram - The subprogram that contains this region. This allows
|
||||
/// efficient stack traversals.
|
||||
SourceSubprogram *CurSubprogram;
|
||||
|
||||
/// CurLine, CurCol, CurFile - The last location visited by this region.
|
||||
/// This is used for getting the source location of callers in stack frames.
|
||||
unsigned CurLine, CurCol;
|
||||
void *CurFileDesc;
|
||||
|
||||
//std::vector<void*> ActiveObjects;
|
||||
public:
|
||||
SourceRegion(SourceRegion *p, SourceSubprogram *Subprogram = 0)
|
||||
: Parent(p), CurSubprogram(Subprogram ? Subprogram : p->getSubprogram()) {
|
||||
CurLine = 0; CurCol = 0;
|
||||
CurFileDesc = 0;
|
||||
}
|
||||
|
||||
virtual ~SourceRegion() {}
|
||||
|
||||
SourceRegion *getParent() const { return Parent; }
|
||||
SourceSubprogram *getSubprogram() const { return CurSubprogram; }
|
||||
|
||||
void updateLocation(unsigned Line, unsigned Col, void *File) {
|
||||
CurLine = Line;
|
||||
CurCol = Col;
|
||||
CurFileDesc = File;
|
||||
}
|
||||
|
||||
/// Return a LocationToken for the place that this stack frame stopped or
|
||||
/// called a sub-function.
|
||||
LocationToken getLocation(ExecutionEngine *EE) {
|
||||
LocationToken LT;
|
||||
LT.Line = CurLine;
|
||||
LT.Col = CurCol;
|
||||
const GlobalValue *GV = EE->getGlobalValueAtAddress(CurFileDesc);
|
||||
LT.File = dyn_cast_or_null<GlobalVariable>(GV);
|
||||
return LT;
|
||||
}
|
||||
};
|
||||
|
||||
/// SourceSubprogram - This is a stack-frame that represents a source program.
|
||||
///
|
||||
class SourceSubprogram : public SourceRegion {
|
||||
/// Desc - A pointer to the descriptor for the subprogram that this frame
|
||||
/// represents.
|
||||
void *Desc;
|
||||
public:
|
||||
SourceSubprogram(SourceRegion *P, void *desc)
|
||||
: SourceRegion(P, this), Desc(desc) {}
|
||||
void *getDescriptor() const { return Desc; }
|
||||
};
|
||||
|
||||
|
||||
/// Child class - This class contains all of the information and methods used
|
||||
/// by the child side of the debugger. The single instance of this object is
|
||||
/// pointed to by the "TheChild" global variable.
|
||||
class Child {
|
||||
/// M - The module for the program currently being debugged.
|
||||
///
|
||||
Module *M;
|
||||
|
||||
/// EE - The execution engine that we are using to run the program.
|
||||
///
|
||||
ExecutionEngine *EE;
|
||||
|
||||
/// ReadFD, WriteFD - The file descriptor handles for this side of the
|
||||
/// debugger pipe.
|
||||
FDHandle ReadFD, WriteFD;
|
||||
|
||||
/// RegionStack - A linked list of all of the regions dynamically active.
|
||||
///
|
||||
SourceRegion *RegionStack;
|
||||
|
||||
/// StopAtNextOpportunity - If this flag is set, the child process will stop
|
||||
/// and report to the debugger at the next possible chance it gets.
|
||||
volatile bool StopAtNextOpportunity;
|
||||
|
||||
/// StopWhenSubprogramReturns - If this is non-null, the debugger requests
|
||||
/// that the program stops when the specified function frame is destroyed.
|
||||
SourceSubprogram *StopWhenSubprogramReturns;
|
||||
|
||||
/// Breakpoints - This contains a list of active breakpoints and their IDs.
|
||||
///
|
||||
std::vector<std::pair<unsigned, LocationToken> > Breakpoints;
|
||||
|
||||
/// CurBreakpoint - The last assigned breakpoint.
|
||||
///
|
||||
unsigned CurBreakpoint;
|
||||
|
||||
public:
|
||||
Child(Module *m, ExecutionEngine *ee, FDHandle &Read, FDHandle &Write)
|
||||
: M(m), EE(ee), ReadFD(Read), WriteFD(Write),
|
||||
RegionStack(0), CurBreakpoint(0) {
|
||||
StopAtNextOpportunity = true;
|
||||
StopWhenSubprogramReturns = 0;
|
||||
}
|
||||
|
||||
/// writeToParent - Send the specified buffer of data to the debugger
|
||||
/// process.
|
||||
void writeToParent(const void *Buffer, unsigned Size);
|
||||
|
||||
/// readFromParent - Read the specified number of bytes from the parent.
|
||||
///
|
||||
void readFromParent(void *Buffer, unsigned Size);
|
||||
|
||||
/// childStopped - This method is called whenever the child has stopped
|
||||
/// execution due to a breakpoint, step command, interruption, or whatever.
|
||||
/// This stops the process, responds to any requests from the debugger, and
|
||||
/// when commanded to, can continue execution by returning.
|
||||
///
|
||||
void childStopped();
|
||||
|
||||
/// startSubprogram - This method creates a new region for the subroutine
|
||||
/// with the specified descriptor.
|
||||
void startSubprogram(void *FuncDesc);
|
||||
|
||||
/// startRegion - This method initiates the creation of an anonymous region.
|
||||
///
|
||||
void startRegion();
|
||||
|
||||
/// endRegion - This method terminates the last active region.
|
||||
///
|
||||
void endRegion();
|
||||
|
||||
/// reachedLine - This method is automatically called by the program every
|
||||
/// time it executes an llvm.dbg.stoppoint intrinsic. If the debugger wants
|
||||
/// us to stop here, we do so, otherwise we continue execution.
|
||||
void reachedLine(unsigned Line, unsigned Col, void *SourceDesc);
|
||||
};
|
||||
|
||||
/// TheChild - The single instance of the Child class, which only gets created
|
||||
/// in the child process.
|
||||
Child *TheChild = 0;
|
||||
} // end anonymous namespace
|
||||
|
||||
|
||||
// writeToParent - Send the specified buffer of data to the debugger process.
|
||||
void Child::writeToParent(const void *Buffer, unsigned Size) {
|
||||
while (Size) {
|
||||
ssize_t Amount = write(WriteFD, Buffer, Size);
|
||||
if (Amount < 0 && errno == EINTR) continue;
|
||||
if (Amount <= 0) {
|
||||
write(2, "ERROR: Connection to debugger lost!\n", 36);
|
||||
abort();
|
||||
} else {
|
||||
// We wrote a chunk.
|
||||
Buffer = (const char*)Buffer + Amount;
|
||||
Size -= Amount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// readFromParent - Read the specified number of bytes from the parent.
|
||||
void Child::readFromParent(void *Buffer, unsigned Size) {
|
||||
while (Size) {
|
||||
ssize_t Amount = read(ReadFD, Buffer, Size);
|
||||
if (Amount < 0 && errno == EINTR) continue;
|
||||
if (Amount <= 0) {
|
||||
write(2, "ERROR: Connection to debugger lost!\n", 36);
|
||||
abort();
|
||||
} else {
|
||||
// We read a chunk.
|
||||
Buffer = (char*)Buffer + Amount;
|
||||
Size -= Amount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// childStopped - This method is called whenever the child has stopped
|
||||
/// execution due to a breakpoint, step command, interruption, or whatever.
|
||||
/// This stops the process, responds to any requests from the debugger, and when
|
||||
/// commanded to, can continue execution by returning.
|
||||
///
|
||||
void Child::childStopped() {
|
||||
// Since we stopped, notify the parent that we did so.
|
||||
char Token = 0;
|
||||
writeToParent(&Token, sizeof(char));
|
||||
|
||||
StopAtNextOpportunity = false;
|
||||
StopWhenSubprogramReturns = 0;
|
||||
|
||||
// Now that the debugger knows that we stopped, read commands from it and
|
||||
// respond to them appropriately.
|
||||
CommandID Command;
|
||||
while (1) {
|
||||
SourceRegion *Frame;
|
||||
const void *Result;
|
||||
readFromParent(&Command, sizeof(CommandID));
|
||||
|
||||
switch (Command) {
|
||||
case StepProgram:
|
||||
// To step the program, just return.
|
||||
StopAtNextOpportunity = true;
|
||||
return;
|
||||
|
||||
case FinishProgram: // Run until exit from the specified function...
|
||||
readFromParent(&Frame, sizeof(Frame));
|
||||
// The user wants us to stop when the specified FUNCTION exits, not when
|
||||
// the specified REGION exits.
|
||||
StopWhenSubprogramReturns = Frame->getSubprogram();
|
||||
return;
|
||||
|
||||
case ContProgram:
|
||||
// To continue, just return back to execution.
|
||||
return;
|
||||
|
||||
case GetSubprogramDescriptor:
|
||||
readFromParent(&Frame, sizeof(Frame));
|
||||
Result =
|
||||
EE->getGlobalValueAtAddress(Frame->getSubprogram()->getDescriptor());
|
||||
writeToParent(&Result, sizeof(Result));
|
||||
break;
|
||||
|
||||
case GetParentFrame:
|
||||
readFromParent(&Frame, sizeof(Frame));
|
||||
Result = Frame ? Frame->getSubprogram()->getParent() : RegionStack;
|
||||
writeToParent(&Result, sizeof(Result));
|
||||
break;
|
||||
|
||||
case GetFrameLocation: {
|
||||
readFromParent(&Frame, sizeof(Frame));
|
||||
LocationToken LT = Frame->getLocation(EE);
|
||||
writeToParent(<, sizeof(LT));
|
||||
break;
|
||||
}
|
||||
case AddBreakpoint: {
|
||||
LocationToken Loc;
|
||||
readFromParent(&Loc, sizeof(Loc));
|
||||
// Convert the GlobalVariable pointer to the address it was emitted to.
|
||||
Loc.File = (GlobalVariable*)EE->getPointerToGlobal(Loc.File);
|
||||
unsigned ID = CurBreakpoint++;
|
||||
Breakpoints.push_back(std::make_pair(ID, Loc));
|
||||
writeToParent(&ID, sizeof(ID));
|
||||
break;
|
||||
}
|
||||
case RemoveBreakpoint: {
|
||||
unsigned ID = 0;
|
||||
readFromParent(&ID, sizeof(ID));
|
||||
for (unsigned i = 0, e = Breakpoints.size(); i != e; ++i)
|
||||
if (Breakpoints[i].first == ID) {
|
||||
Breakpoints.erase(Breakpoints.begin()+i);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
assert(0 && "Unknown command!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// startSubprogram - This method creates a new region for the subroutine
|
||||
/// with the specified descriptor.
|
||||
void Child::startSubprogram(void *SPDesc) {
|
||||
RegionStack = new SourceSubprogram(RegionStack, SPDesc);
|
||||
}
|
||||
|
||||
/// startRegion - This method initiates the creation of an anonymous region.
|
||||
///
|
||||
void Child::startRegion() {
|
||||
RegionStack = new SourceRegion(RegionStack);
|
||||
}
|
||||
|
||||
/// endRegion - This method terminates the last active region.
|
||||
///
|
||||
void Child::endRegion() {
|
||||
SourceRegion *R = RegionStack->getParent();
|
||||
|
||||
// If the debugger wants us to stop when this frame is destroyed, do so.
|
||||
if (RegionStack == StopWhenSubprogramReturns) {
|
||||
StopAtNextOpportunity = true;
|
||||
StopWhenSubprogramReturns = 0;
|
||||
}
|
||||
|
||||
delete RegionStack;
|
||||
RegionStack = R;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/// reachedLine - This method is automatically called by the program every time
|
||||
/// it executes an llvm.dbg.stoppoint intrinsic. If the debugger wants us to
|
||||
/// stop here, we do so, otherwise we continue execution. Note that the Data
|
||||
/// pointer coming in is a pointer to the LLVM global variable that represents
|
||||
/// the source file we are in. We do not use the contents of the global
|
||||
/// directly in the child, but we do use its address.
|
||||
///
|
||||
void Child::reachedLine(unsigned Line, unsigned Col, void *SourceDesc) {
|
||||
if (RegionStack)
|
||||
RegionStack->updateLocation(Line, Col, SourceDesc);
|
||||
|
||||
// If we hit a breakpoint, stop the program.
|
||||
for (unsigned i = 0, e = Breakpoints.size(); i != e; ++i)
|
||||
if (Line == Breakpoints[i].second.Line &&
|
||||
SourceDesc == (void*)Breakpoints[i].second.File &&
|
||||
Col == Breakpoints[i].second.Col) {
|
||||
childStopped();
|
||||
return;
|
||||
}
|
||||
|
||||
// If we are single stepping the program, make sure to stop it.
|
||||
if (StopAtNextOpportunity)
|
||||
childStopped();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Child class wrapper functions
|
||||
//
|
||||
// These functions are invoked directly by the program as it executes, in place
|
||||
// of the debugging intrinsic functions that it contains.
|
||||
//
|
||||
|
||||
|
||||
/// llvm_debugger_stop - Every time the program reaches a new source line, it
|
||||
/// will call back to this function. If the debugger has a breakpoint or
|
||||
/// otherwise wants us to stop on this line, we do so, and notify the debugger
|
||||
/// over the pipe.
|
||||
///
|
||||
extern "C"
|
||||
void *llvm_debugger_stop(void *Dummy, unsigned Line, unsigned Col,
|
||||
void *SourceDescriptor) {
|
||||
TheChild->reachedLine(Line, Col, SourceDescriptor);
|
||||
return Dummy;
|
||||
}
|
||||
|
||||
|
||||
/// llvm_dbg_region_start - This function is invoked every time an anonymous
|
||||
/// region of the source program is entered.
|
||||
///
|
||||
extern "C"
|
||||
void *llvm_dbg_region_start(void *Dummy) {
|
||||
TheChild->startRegion();
|
||||
return Dummy;
|
||||
}
|
||||
|
||||
/// llvm_dbg_subprogram - This function is invoked every time a source-language
|
||||
/// subprogram has been entered.
|
||||
///
|
||||
extern "C"
|
||||
void *llvm_dbg_subprogram(void *FuncDesc) {
|
||||
TheChild->startSubprogram(FuncDesc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// llvm_dbg_region_end - This function is invoked every time a source-language
|
||||
/// region (started with llvm.dbg.region.start or llvm.dbg.func.start) is
|
||||
/// terminated.
|
||||
///
|
||||
extern "C"
|
||||
void llvm_dbg_region_end(void *Dummy) {
|
||||
TheChild->endRegion();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
namespace {
|
||||
/// DebuggerIntrinsicLowering - This class implements a simple intrinsic
|
||||
/// lowering class that revectors debugging intrinsics to call actual
|
||||
/// functions (defined above), instead of being turned into noops.
|
||||
struct DebuggerIntrinsicLowering : public DefaultIntrinsicLowering {
|
||||
virtual void LowerIntrinsicCall(CallInst *CI) {
|
||||
Module *M = CI->getParent()->getParent()->getParent();
|
||||
switch (CI->getCalledFunction()->getIntrinsicID()) {
|
||||
case Intrinsic::dbg_stoppoint:
|
||||
// Turn call into a call to llvm_debugger_stop
|
||||
CI->setOperand(0, M->getOrInsertFunction("llvm_debugger_stop",
|
||||
CI->getCalledFunction()->getFunctionType()));
|
||||
break;
|
||||
case Intrinsic::dbg_region_start:
|
||||
// Turn call into a call to llvm_dbg_region_start
|
||||
CI->setOperand(0, M->getOrInsertFunction("llvm_dbg_region_start",
|
||||
CI->getCalledFunction()->getFunctionType()));
|
||||
break;
|
||||
|
||||
case Intrinsic::dbg_region_end:
|
||||
// Turn call into a call to llvm_debugger_stop
|
||||
CI->setOperand(0, M->getOrInsertFunction("llvm_dbg_region_end",
|
||||
CI->getCalledFunction()->getFunctionType()));
|
||||
break;
|
||||
case Intrinsic::dbg_func_start:
|
||||
// Turn call into a call to llvm_debugger_stop
|
||||
CI->setOperand(0, M->getOrInsertFunction("llvm_dbg_subprogram",
|
||||
CI->getCalledFunction()->getFunctionType()));
|
||||
break;
|
||||
default:
|
||||
DefaultIntrinsicLowering::LowerIntrinsicCall(CI);
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
} // end anonymous namespace
|
||||
|
||||
|
||||
static void runChild(Module *M, const std::vector<std::string> &Arguments,
|
||||
const char * const *envp,
|
||||
FDHandle ReadFD, FDHandle WriteFD) {
|
||||
|
||||
// Create an execution engine that uses our custom intrinsic lowering object
|
||||
// to revector debugging intrinsic functions into actual functions defined
|
||||
// above.
|
||||
ExecutionEngine *EE =
|
||||
ExecutionEngine::create(new ExistingModuleProvider(M), false,
|
||||
new DebuggerIntrinsicLowering());
|
||||
assert(EE && "Couldn't create an ExecutionEngine, not even an interpreter?");
|
||||
|
||||
// Call the main function from M as if its signature were:
|
||||
// int main (int argc, char **argv, const char **envp)
|
||||
// using the contents of Args to determine argc & argv, and the contents of
|
||||
// EnvVars to determine envp.
|
||||
//
|
||||
Function *Fn = M->getMainFunction();
|
||||
if (!Fn) exit(1);
|
||||
|
||||
// Create the child class instance which will be used by the debugger
|
||||
// callbacks to keep track of the current state of the process.
|
||||
assert(TheChild == 0 && "A child process has already been created??");
|
||||
TheChild = new Child(M, EE, ReadFD, WriteFD);
|
||||
|
||||
// Run main...
|
||||
int Result = EE->runFunctionAsMain(Fn, Arguments, envp);
|
||||
|
||||
// If the program didn't explicitly call exit, call exit now, for the program.
|
||||
// This ensures that any atexit handlers get called correctly.
|
||||
Function *Exit = M->getOrInsertFunction("exit", Type::VoidTy, Type::IntTy, 0);
|
||||
|
||||
std::vector<GenericValue> Args;
|
||||
GenericValue ResultGV;
|
||||
ResultGV.IntVal = Result;
|
||||
Args.push_back(ResultGV);
|
||||
EE->runFunction(Exit, Args);
|
||||
abort();
|
||||
}
|
||||
Loading…
Reference in New Issue