forked from OSchip/llvm-project
310 lines
9.3 KiB
C++
310 lines
9.3 KiB
C++
//===--- index-test.cpp - Indexing test bed -------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This utility may be invoked in the following manner:
|
|
// index-test --help - Output help info.
|
|
// index-test [options] - Read from stdin.
|
|
// index-test [options] file - Read from "file".
|
|
// index-test [options] file1 file2 - Read these files.
|
|
//
|
|
// Files must be AST files.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// -point-at [file:line:column]
|
|
// Point at a declaration/statement/expression. If no other operation is
|
|
// specified, prints some info about it.
|
|
//
|
|
// -print-refs
|
|
// Print ASTLocations that reference the -point-at node
|
|
//
|
|
// -print-defs
|
|
// Print ASTLocations that define the -point-at node
|
|
//
|
|
// -print-decls
|
|
// Print ASTLocations that declare the -point-at node
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Index/Program.h"
|
|
#include "clang/Index/Indexer.h"
|
|
#include "clang/Index/Entity.h"
|
|
#include "clang/Index/TranslationUnit.h"
|
|
#include "clang/Index/ASTLocation.h"
|
|
#include "clang/Index/DeclReferenceMap.h"
|
|
#include "clang/Index/SelectorMap.h"
|
|
#include "clang/Index/Handlers.h"
|
|
#include "clang/Index/Analyzer.h"
|
|
#include "clang/Index/Utils.h"
|
|
#include "clang/Frontend/ASTUnit.h"
|
|
#include "clang/Frontend/CommandLineSourceLoc.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
#include "clang/AST/ExprObjC.h"
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/System/Signals.h"
|
|
using namespace clang;
|
|
using namespace idx;
|
|
|
|
class TUnit : public TranslationUnit {
|
|
public:
|
|
TUnit(ASTUnit *ast, const std::string &filename)
|
|
: AST(ast), Filename(filename),
|
|
DeclRefMap(ast->getASTContext()),
|
|
SelMap(ast->getASTContext()) { }
|
|
|
|
virtual ASTContext &getASTContext() { return AST->getASTContext(); }
|
|
virtual DeclReferenceMap &getDeclReferenceMap() { return DeclRefMap; }
|
|
virtual SelectorMap &getSelectorMap() { return SelMap; }
|
|
|
|
llvm::OwningPtr<ASTUnit> AST;
|
|
std::string Filename;
|
|
DeclReferenceMap DeclRefMap;
|
|
SelectorMap SelMap;
|
|
};
|
|
|
|
static llvm::cl::list<ParsedSourceLocation>
|
|
PointAtLocation("point-at", llvm::cl::Optional,
|
|
llvm::cl::value_desc("source-location"),
|
|
llvm::cl::desc("Point at the given source location of the first AST file"));
|
|
|
|
enum ProgActions {
|
|
PrintPoint, // Just print the point-at node
|
|
PrintRefs, // Print references of the point-at node
|
|
PrintDefs, // Print definitions of the point-at node
|
|
PrintDecls // Print declarations of the point-at node
|
|
};
|
|
|
|
static llvm::cl::opt<ProgActions>
|
|
ProgAction(
|
|
llvm::cl::desc("Choose action to perform on the pointed-at AST node:"),
|
|
llvm::cl::ZeroOrMore,
|
|
llvm::cl::init(PrintPoint),
|
|
llvm::cl::values(
|
|
clEnumValN(PrintRefs, "print-refs",
|
|
"Print references"),
|
|
clEnumValN(PrintDefs, "print-defs",
|
|
"Print definitions"),
|
|
clEnumValN(PrintDecls, "print-decls",
|
|
"Print declarations"),
|
|
clEnumValEnd));
|
|
|
|
static llvm::cl::opt<bool>
|
|
DisableFree("disable-free",
|
|
llvm::cl::desc("Disable freeing of memory on exit"),
|
|
llvm::cl::init(false));
|
|
|
|
static bool HadErrors = false;
|
|
|
|
static void ProcessObjCMessage(ObjCMessageExpr *Msg, Indexer &Idxer) {
|
|
llvm::raw_ostream &OS = llvm::outs();
|
|
typedef Storing<TULocationHandler> ResultsTy;
|
|
ResultsTy Results;
|
|
|
|
Analyzer Analyz(Idxer.getProgram(), Idxer);
|
|
|
|
switch (ProgAction) {
|
|
default: assert(0);
|
|
case PrintRefs:
|
|
llvm::errs() << "Error: Cannot -print-refs on a ObjC message expression\n";
|
|
HadErrors = true;
|
|
return;
|
|
|
|
case PrintDecls: {
|
|
Analyz.FindObjCMethods(Msg, Results);
|
|
for (ResultsTy::iterator
|
|
I = Results.begin(), E = Results.end(); I != E; ++I)
|
|
I->print(OS);
|
|
break;
|
|
}
|
|
|
|
case PrintDefs: {
|
|
Analyz.FindObjCMethods(Msg, Results);
|
|
for (ResultsTy::iterator
|
|
I = Results.begin(), E = Results.end(); I != E; ++I) {
|
|
const ObjCMethodDecl *D = cast<ObjCMethodDecl>(I->getDecl());
|
|
if (D->isThisDeclarationADefinition())
|
|
I->print(OS);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static void ProcessASTLocation(ASTLocation ASTLoc, Indexer &Idxer) {
|
|
assert(ASTLoc.isValid());
|
|
|
|
if (ObjCMessageExpr *Msg =
|
|
dyn_cast_or_null<ObjCMessageExpr>(ASTLoc.getStmt()))
|
|
return ProcessObjCMessage(Msg, Idxer);
|
|
|
|
Decl *D = ASTLoc.getReferencedDecl();
|
|
if (D == 0) {
|
|
llvm::errs() << "Error: Couldn't get referenced Decl for the ASTLocation\n";
|
|
HadErrors = true;
|
|
return;
|
|
}
|
|
|
|
llvm::raw_ostream &OS = llvm::outs();
|
|
typedef Storing<TULocationHandler> ResultsTy;
|
|
ResultsTy Results;
|
|
|
|
Analyzer Analyz(Idxer.getProgram(), Idxer);
|
|
|
|
switch (ProgAction) {
|
|
default: assert(0);
|
|
case PrintRefs: {
|
|
Analyz.FindReferences(D, Results);
|
|
for (ResultsTy::iterator
|
|
I = Results.begin(), E = Results.end(); I != E; ++I)
|
|
I->print(OS);
|
|
break;
|
|
}
|
|
|
|
case PrintDecls: {
|
|
Analyz.FindDeclarations(D, Results);
|
|
for (ResultsTy::iterator
|
|
I = Results.begin(), E = Results.end(); I != E; ++I)
|
|
I->print(OS);
|
|
break;
|
|
}
|
|
|
|
case PrintDefs: {
|
|
Analyz.FindDeclarations(D, Results);
|
|
for (ResultsTy::iterator
|
|
I = Results.begin(), E = Results.end(); I != E; ++I) {
|
|
const Decl *D = I->getDecl();
|
|
bool isDef = false;
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
|
|
isDef = FD->isThisDeclarationADefinition();
|
|
else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
|
|
isDef = VD->getInit() != 0;
|
|
else if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
|
|
isDef = MD->isThisDeclarationADefinition();
|
|
|
|
if (isDef)
|
|
I->print(OS);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static llvm::cl::list<std::string>
|
|
InputFilenames(llvm::cl::Positional, llvm::cl::desc("<input AST files>"));
|
|
|
|
int main(int argc, char **argv) {
|
|
llvm::sys::PrintStackTraceOnErrorSignal();
|
|
llvm::PrettyStackTraceProgram X(argc, argv);
|
|
llvm::cl::ParseCommandLineOptions(argc, argv,
|
|
"LLVM 'Clang' Indexing Test Bed: http://clang.llvm.org\n");
|
|
|
|
FileManager FileMgr;
|
|
|
|
Program Prog;
|
|
Indexer Idxer(Prog);
|
|
llvm::SmallVector<TUnit*, 4> TUnits;
|
|
|
|
// If no input was specified, read from stdin.
|
|
if (InputFilenames.empty())
|
|
InputFilenames.push_back("-");
|
|
|
|
for (unsigned i = 0, e = InputFilenames.size(); i != e; ++i) {
|
|
const std::string &InFile = InputFilenames[i];
|
|
|
|
std::string ErrMsg;
|
|
llvm::OwningPtr<ASTUnit> AST;
|
|
|
|
AST.reset(ASTUnit::LoadFromPCHFile(InFile, FileMgr, &ErrMsg));
|
|
if (!AST) {
|
|
llvm::errs() << "[" << InFile << "] Error: " << ErrMsg << '\n';
|
|
return 1;
|
|
}
|
|
|
|
TUnit *TU = new TUnit(AST.take(), InFile);
|
|
TUnits.push_back(TU);
|
|
|
|
Idxer.IndexAST(TU);
|
|
}
|
|
|
|
ASTLocation ASTLoc;
|
|
const std::string &FirstFile = TUnits[0]->Filename;
|
|
ASTUnit *FirstAST = TUnits[0]->AST.get();
|
|
|
|
if (!PointAtLocation.empty()) {
|
|
const std::string &Filename = PointAtLocation[0].FileName;
|
|
const FileEntry *File = FileMgr.getFile(Filename);
|
|
if (File == 0) {
|
|
llvm::errs() << "File '" << Filename << "' does not exist\n";
|
|
return 1;
|
|
}
|
|
|
|
// Safety check. Using an out-of-date AST file will only lead to crashes
|
|
// or incorrect results.
|
|
// FIXME: Check all the source files that make up the AST file.
|
|
const FileEntry *ASTFile = FileMgr.getFile(FirstFile);
|
|
if (File->getModificationTime() > ASTFile->getModificationTime()) {
|
|
llvm::errs() << "[" << FirstFile << "] Error: " <<
|
|
"Pointing at a source file which was modified after creating "
|
|
"the AST file\n";
|
|
return 1;
|
|
}
|
|
|
|
unsigned Line = PointAtLocation[0].Line;
|
|
unsigned Col = PointAtLocation[0].Column;
|
|
|
|
SourceLocation Loc =
|
|
FirstAST->getSourceManager().getLocation(File, Line, Col);
|
|
if (Loc.isInvalid()) {
|
|
llvm::errs() << "[" << FirstFile << "] Error: " <<
|
|
"Couldn't resolve source location (invalid location)\n";
|
|
return 1;
|
|
}
|
|
|
|
ASTLoc = ResolveLocationInAST(FirstAST->getASTContext(), Loc);
|
|
if (ASTLoc.isInvalid()) {
|
|
llvm::errs() << "[" << FirstFile << "] Error: " <<
|
|
"Couldn't resolve source location (no declaration found)\n";
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (ASTLoc.isValid()) {
|
|
if (ProgAction == PrintPoint) {
|
|
llvm::raw_ostream &OS = llvm::outs();
|
|
ASTLoc.print(OS);
|
|
if (const char *Comment =
|
|
FirstAST->getASTContext().getCommentForDecl(ASTLoc.getDecl()))
|
|
OS << "Comment associated with this declaration:\n" << Comment << "\n";
|
|
} else {
|
|
ProcessASTLocation(ASTLoc, Idxer);
|
|
}
|
|
}
|
|
|
|
if (HadErrors)
|
|
return 1;
|
|
|
|
if (!DisableFree) {
|
|
for (int i=0, e=TUnits.size(); i != e; ++i)
|
|
delete TUnits[i];
|
|
}
|
|
|
|
// Managed static deconstruction. Useful for making things like
|
|
// -time-passes usable.
|
|
llvm::llvm_shutdown();
|
|
|
|
return 0;
|
|
}
|