#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"
}
}
-/// 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->isString()) {
- 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 (GlobalValue *GV = dyn_cast<GlobalValue>(C))
- return getStringValue(GV, 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
// 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;
+ if (const DbgStopPointInst *SPI = dyn_cast<DbgStopPointInst>(CI)) {
+ unsigned CurLineNo = SPI->getLine();
+ unsigned CurColNo = SPI->getColumn();
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);
+ const Value *Op = SPI->getContext();
if ((CurDesc = dyn_cast<GlobalVariable>(Op)) &&
(LineNo < LastLineNo ||
}
ShouldRecurse = false;
}
-
}
// If this is not a phi node or a stopping point, recursively scan the users
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();
+ if (ConstantInt *CUI = dyn_cast<ConstantInt>(CS->getOperand(1)))
+ Version = CUI->getZExtValue();
- BaseName = getStringValue(CS->getOperand(3));
- Directory = getStringValue(CS->getOperand(4));
+ BaseName = CS->getOperand(3)->getStringValue();
+ Directory = CS->getOperand(4)->getStringValue();
}
}
if (SourceText == 0) { // Read the file in if we haven't already.
sys::Path tmpPath;
if (!Directory.empty())
- tmpPath.setDirectory(Directory);
- tmpPath.appendFile(BaseName);
- if (tmpPath.readable())
+ tmpPath.set(Directory);
+ tmpPath.appendComponent(BaseName);
+ if (tmpPath.canRead())
SourceText = new SourceFile(tmpPath.toString(), Descriptor);
else
SourceText = new SourceFile(BaseName, Descriptor);
SourceFile = &PI.getSourceFile(GV);
// Entry #2 is the function name.
- Name = getStringValue(CS->getOperand(2));
+ Name = CS->getOperand(2)->getStringValue();
}
}
ProgramInfo::ProgramInfo(Module *m) : M(m), ProgramTimeStamp(0,0) {
assert(M && "Cannot create program information with a null module!");
- sys::Path modulePath(M->getModuleIdentifier());
- ProgramTimeStamp = modulePath.getTimestamp();
+ sys::FileStatus Stat;
+ if (!sys::Path(M->getModuleIdentifier()).getFileStatus(Stat))
+ ProgramTimeStamp = Stat.getTimestamp();
SourceFilesIsComplete = false;
SourceFunctionsIsComplete = false;
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();
+ if (ConstantInt *CUI = dyn_cast<ConstantInt>(CS->getOperand(2)))
+ LangID = CUI->getZExtValue();
const SourceLanguage &Lang = SourceLanguage::get(LangID);
SourceFileInfo *New = Lang.createSourceFileInfo(Desc, *this);
// mapping.
for (unsigned i = 0, e = TranslationUnits.size(); i != e; ++i) {
getSourceFile(TranslationUnits[i]);
- SOI.progress(i+1, e);
+ 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.
// 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);
+ if (SOI.progress(i+1, e))
+ throw "While functions index, operation cancelled.";
}
// Ok, if we got this far, then we indexed the whole program.
projects / oota-llvm.git / blobdiff