It's not necessary to do rounding for alloca operations when the requested
alignment is equal to the stack alignment.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40004 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Debugger/Debugger.cpp b/lib/Debugger/Debugger.cpp
new file mode 100644
index 0000000..a38bde7
--- /dev/null
+++ b/lib/Debugger/Debugger.cpp
@@ -0,0 +1,229 @@
+//===-- 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/Bitcode/ReaderWriter.h"
+#include "llvm/Debugger/InferiorProcess.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/ADT/StringExtras.h"
+#include <memory>
+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) {
+ std::auto_ptr<MemoryBuffer> Buffer;
+ Buffer.reset(MemoryBuffer::getFileOrSTDIN(&Filename[0], Filename.size()));
+ if (Buffer.get())
+ return ParseBitcodeFile(Buffer.get());
+ 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);
+}
+
+InferiorProcess *
+InferiorProcess::create(Module *M, const std::vector<std::string> &Arguments,
+ const char * const *envp) {
+ throw"No supported binding to inferior processes (debugger not implemented).";
+}
+
+/// 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.
+ try {
+ delete Process;
+ } catch (...) {
+ Process = 0;
+ throw;
+ }
+ 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) {
+ killProgram();
+ throw NonErrorException("The program stopped with exit code " +
+ itostr(IPD.getExitCode()));
+ } catch (...) {
+ killProgram();
+ throw;
+ }
+}
+
+/// 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) {
+ killProgram();
+ throw NonErrorException("The program stopped with exit code " +
+ itostr(IPD.getExitCode()));
+ } catch (...) {
+ killProgram();
+ throw;
+ }
+}
+
+/// 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) {
+ killProgram();
+ throw NonErrorException("The program stopped with exit code " +
+ itostr(IPD.getExitCode()));
+ } catch (...) {
+ killProgram();
+ throw;
+ }
+}
+
+/// 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) {
+ killProgram();
+ throw NonErrorException("The program stopped with exit code " +
+ itostr(IPD.getExitCode()));
+ } catch (...) {
+ killProgram();
+ throw;
+ }
+}
diff --git a/lib/Debugger/Makefile b/lib/Debugger/Makefile
new file mode 100644
index 0000000..c322064
--- /dev/null
+++ b/lib/Debugger/Makefile
@@ -0,0 +1,16 @@
+##===- 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 = LLVMDebugger
+EXTRA_DIST = README.txt
+REQUIRES_EH := 1
+BUILD_ARCHIVE = 1
+
+include $(LEVEL)/Makefile.common
diff --git a/lib/Debugger/ProgramInfo.cpp b/lib/Debugger/ProgramInfo.cpp
new file mode 100644
index 0000000..9d987ea
--- /dev/null
+++ b/lib/Debugger/ProgramInfo.cpp
@@ -0,0 +1,372 @@
+//===-- 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/IntrinsicInst.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/Debugger/SourceFile.h"
+#include "llvm/Debugger/SourceLanguage.h"
+#include "llvm/Support/SlowOperationInformer.h"
+#include "llvm/ADT/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);
+ }
+}
+
+/// 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 (CI->getCalledFunction())
+ if (const DbgStopPointInst *SPI = dyn_cast<DbgStopPointInst>(CI)) {
+ unsigned CurLineNo = SPI->getLine();
+ unsigned CurColNo = SPI->getColumn();
+ const GlobalVariable *CurDesc = 0;
+ const Value *Op = SPI->getContext();
+
+ 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 (ConstantInt *CUI = dyn_cast<ConstantInt>(CS->getOperand(1)))
+ Version = CUI->getZExtValue();
+
+ BaseName = CS->getOperand(3)->getStringValue();
+ Directory = CS->getOperand(4)->getStringValue();
+ }
+}
+
+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.
+ sys::Path tmpPath;
+ if (!Directory.empty())
+ tmpPath.set(Directory);
+ tmpPath.appendComponent(BaseName);
+ if (tmpPath.canRead())
+ SourceText = new SourceFile(tmpPath.toString(), 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 GlobalVariable *GV =
+ dyn_cast<GlobalVariable>(CS->getOperand(1)))
+ SourceFile = &PI.getSourceFile(GV);
+
+ // Entry #2 is the function name.
+ Name = CS->getOperand(2)->getStringValue();
+ }
+}
+
+/// 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)
+ 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), ProgramTimeStamp(0,0) {
+ assert(M && "Cannot create program information with a null module!");
+ sys::PathWithStatus ModPath(M->getModuleIdentifier());
+ const sys::FileStatus *Stat = ModPath.getFileStatus();
+ if (Stat)
+ ProgramTimeStamp = Stat->getTimestamp();
+
+ 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 (ConstantInt *CUI = dyn_cast<ConstantInt>(CS->getOperand(2)))
+ LangID = CUI->getZExtValue();
+
+ 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]);
+ if (SOI.progress(i+1, e))
+ throw "While building source files index, operation cancelled.";
+ }
+
+ // 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 GlobalVariable *GV =
+ dyn_cast<GlobalVariable>(CS->getOperand(1)))
+ SourceFileDesc = GV;
+
+ 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]);
+ if (SOI.progress(i+1, e))
+ throw "While functions index, operation cancelled.";
+ }
+
+ // Ok, if we got this far, then we indexed the whole program.
+ SourceFunctionsIsComplete = true;
+ return SourceFunctions;
+}
diff --git a/lib/Debugger/README.txt b/lib/Debugger/README.txt
new file mode 100644
index 0000000..04a18fe
--- /dev/null
+++ b/lib/Debugger/README.txt
@@ -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.
+
diff --git a/lib/Debugger/RuntimeInfo.cpp b/lib/Debugger/RuntimeInfo.cpp
new file mode 100644
index 0000000..5d45104
--- /dev/null
+++ b/lib/Debugger/RuntimeInfo.cpp
@@ -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();
+ }
+}
diff --git a/lib/Debugger/SourceFile.cpp b/lib/Debugger/SourceFile.cpp
new file mode 100644
index 0000000..ebea307
--- /dev/null
+++ b/lib/Debugger/SourceFile.cpp
@@ -0,0 +1,76 @@
+//===-- 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 <cassert>
+
+using namespace llvm;
+
+/// readFile - Load Filename
+///
+void SourceFile::readFile() {
+ std::string ErrMsg;
+ if (!File.map(&ErrMsg))
+ throw ErrMsg;
+}
+
+/// calculateLineOffsets - Compute the LineOffset vector for the current file.
+///
+void SourceFile::calculateLineOffsets() const {
+ assert(LineOffset.empty() && "Line offsets already computed!");
+ const char *BufPtr = File.charBase();
+ const char *FileStart = BufPtr;
+ const char *FileEnd = FileStart + File.size();
+ 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 (!File.isMapped()) 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 = File.charBase()+LineOffset[LineNo];
+
+ if (LineNo+1 < LineOffset.size())
+ LineEnd = File.charBase()+LineOffset[LineNo+1];
+ else
+ LineEnd = File.charBase() + File.size();
+
+ // 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!");
+}
diff --git a/lib/Debugger/SourceLanguage-CFamily.cpp b/lib/Debugger/SourceLanguage-CFamily.cpp
new file mode 100644
index 0000000..468fe0c
--- /dev/null
+++ b/lib/Debugger/SourceLanguage-CFamily.cpp
@@ -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
+}
diff --git a/lib/Debugger/SourceLanguage-CPlusPlus.cpp b/lib/Debugger/SourceLanguage-CPlusPlus.cpp
new file mode 100644
index 0000000..b22163d
--- /dev/null
+++ b/lib/Debugger/SourceLanguage-CPlusPlus.cpp
@@ -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
+}
diff --git a/lib/Debugger/SourceLanguage-Unknown.cpp b/lib/Debugger/SourceLanguage-Unknown.cpp
new file mode 100644
index 0000000..c5d912a
--- /dev/null
+++ b/lib/Debugger/SourceLanguage-Unknown.cpp
@@ -0,0 +1,138 @@
+//===-- 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 "llvm/Support/Streams.h"
+#include <cassert>
+#include <ostream>
+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)
+ cout << "Whoa, found multiple functions with the same name. I should"
+ << " ask the user which one to use: FIXME!\n";
+ return Found;
+}
diff --git a/lib/Debugger/SourceLanguage.cpp b/lib/Debugger/SourceLanguage.cpp
new file mode 100644
index 0000000..8e4b4e0
--- /dev/null
+++ b/lib/Debugger/SourceLanguage.cpp
@@ -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);
+}