//===-- 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/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Intrinsics.h"
-#include "llvm/iOther.h"
+#include "llvm/IntrinsicInst.h"
+#include "llvm/Instructions.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"
+#include "llvm/Support/SlowOperationInformer.h"
+#include "llvm/ADT/STLExtras.h"
+#include <iostream>
+
using namespace llvm;
/// getGlobalVariablesUsing - Return all of the global variables which have the
}
}
-/// 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 (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
// 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);
- if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Op))
- Op = CPR->getValue();
-
+ const Value *Op = SPI->getContext();
+
if ((CurDesc = dyn_cast<GlobalVariable>(Op)) &&
(LineNo < LastLineNo ||
(LineNo == LastLineNo && ColNo < LastColNo))) {
LastDesc = CurDesc;
LastLineNo = CurLineNo;
- LastColNo = CurColNo;
+ LastColNo = CurColNo;
}
ShouldRecurse = false;
}
-
}
// If this is not a phi node or a stopping point, recursively scan the users
if (LineNo < LastLineNo || (LineNo == LastLineNo && ColNo < LastColNo)){
LastDesc = GV;
LastLineNo = CurLineNo;
- LastColNo = CurColNo;
+ LastColNo = CurColNo;
}
}
}
}
-
+
if (LastDesc) {
LineNo = LastLineNo != ~0U ? LastLineNo : 0;
ColNo = LastColNo != ~0U ? LastColNo : 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));
+ if (ConstantInt *CUI = dyn_cast<ConstantInt>(CS->getOperand(1)))
+ Version = CUI->getZExtValue();
+
+ BaseName = CS->getOperand(3)->getStringValue();
+ Directory = CS->getOperand(4)->getStringValue();
}
}
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);
+ 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;
}
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);
+ if (const GlobalVariable *GV =
+ dyn_cast<GlobalVariable>(CS->getOperand(1)))
+ SourceFile = &PI.getSourceFile(GV);
// Entry #2 is the function name.
- Name = getStringValue(CS->getOperand(2));
+ Name = CS->getOperand(2)->getStringValue();
}
}
// ProgramInfo implementation
//
-ProgramInfo::ProgramInfo(Module *m) : M(m) {
+ProgramInfo::ProgramInfo(Module *m) : M(m), ProgramTimeStamp(0,0) {
assert(M && "Cannot create program information with a null module!");
- ProgramTimeStamp = getFileTimestamp(M->getModuleIdentifier());
+ 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.
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 (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());
+ if (const GlobalVariable *GV =
+ dyn_cast<GlobalVariable>(CS->getOperand(1)))
+ SourceFileDesc = GV;
const SourceLanguage &Lang = getSourceFile(SourceFileDesc).getLanguage();
return *(Result = Lang.createSourceFunctionInfo(Desc, *this));
// 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