mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-23 02:29:18 +00:00
into their new header subdirectory: include/llvm/IR. This matches the directory structure of lib, and begins to correct a long standing point of file layout clutter in LLVM. There are still more header files to move here, but I wanted to handle them in separate commits to make tracking what files make sense at each layer easier. The only really questionable files here are the target intrinsic tablegen files. But that's a battle I'd rather not fight today. I've updated both CMake and Makefile build systems (I think, and my tests think, but I may have missed something). I've also re-sorted the includes throughout the project. I'll be committing updates to Clang, DragonEgg, and Polly momentarily. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171366 91177308-0d34-0410-b5e6-96231b3b80d8
434 lines
14 KiB
C++
434 lines
14 KiB
C++
//===- PathProfileInfo.cpp ------------------------------------*- C++ -*---===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the interface used by optimizers to load path profiles,
|
|
// and provides a loader pass which reads a path profile file.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#define DEBUG_TYPE "path-profile-info"
|
|
|
|
#include "llvm/Analysis/PathProfileInfo.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/Analysis/ProfileInfoTypes.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cstdio>
|
|
|
|
using namespace llvm;
|
|
|
|
// command line option for loading path profiles
|
|
static cl::opt<std::string>
|
|
PathProfileInfoFilename("path-profile-loader-file", cl::init("llvmprof.out"),
|
|
cl::value_desc("filename"),
|
|
cl::desc("Path profile file loaded by -path-profile-loader"), cl::Hidden);
|
|
|
|
namespace {
|
|
class PathProfileLoaderPass : public ModulePass, public PathProfileInfo {
|
|
public:
|
|
PathProfileLoaderPass() : ModulePass(ID) { }
|
|
~PathProfileLoaderPass();
|
|
|
|
// this pass doesn't change anything (only loads information)
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
}
|
|
|
|
// the full name of the loader pass
|
|
virtual const char* getPassName() const {
|
|
return "Path Profiling Information Loader";
|
|
}
|
|
|
|
// required since this pass implements multiple inheritance
|
|
virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
|
|
if (PI == &PathProfileInfo::ID)
|
|
return (PathProfileInfo*)this;
|
|
return this;
|
|
}
|
|
|
|
// entry point to run the pass
|
|
bool runOnModule(Module &M);
|
|
|
|
// pass identification
|
|
static char ID;
|
|
|
|
private:
|
|
// make a reference table to refer to function by number
|
|
void buildFunctionRefs(Module &M);
|
|
|
|
// process argument info of a program from the input file
|
|
void handleArgumentInfo();
|
|
|
|
// process path number information from the input file
|
|
void handlePathInfo();
|
|
|
|
// array of references to the functions in the module
|
|
std::vector<Function*> _functions;
|
|
|
|
// path profile file handle
|
|
FILE* _file;
|
|
|
|
// path profile file name
|
|
std::string _filename;
|
|
};
|
|
}
|
|
|
|
// register PathLoader
|
|
char PathProfileLoaderPass::ID = 0;
|
|
|
|
INITIALIZE_ANALYSIS_GROUP(PathProfileInfo, "Path Profile Information",
|
|
NoPathProfileInfo)
|
|
INITIALIZE_AG_PASS(PathProfileLoaderPass, PathProfileInfo,
|
|
"path-profile-loader",
|
|
"Load path profile information from file",
|
|
false, true, false)
|
|
|
|
char &llvm::PathProfileLoaderPassID = PathProfileLoaderPass::ID;
|
|
|
|
// link PathLoader as a pass, and make it available as an optimisation
|
|
ModulePass *llvm::createPathProfileLoaderPass() {
|
|
return new PathProfileLoaderPass;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// PathEdge implementation
|
|
//
|
|
ProfilePathEdge::ProfilePathEdge (BasicBlock* source, BasicBlock* target,
|
|
unsigned duplicateNumber)
|
|
: _source(source), _target(target), _duplicateNumber(duplicateNumber) {}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Path implementation
|
|
//
|
|
|
|
ProfilePath::ProfilePath (unsigned int number, unsigned int count,
|
|
double countStdDev, PathProfileInfo* ppi)
|
|
: _number(number) , _count(count), _countStdDev(countStdDev), _ppi(ppi) {}
|
|
|
|
double ProfilePath::getFrequency() const {
|
|
return 100 * double(_count) /
|
|
double(_ppi->_functionPathCounts[_ppi->_currentFunction]);
|
|
}
|
|
|
|
static BallLarusEdge* getNextEdge (BallLarusNode* node,
|
|
unsigned int pathNumber) {
|
|
BallLarusEdge* best = 0;
|
|
|
|
for( BLEdgeIterator next = node->succBegin(),
|
|
end = node->succEnd(); next != end; next++ ) {
|
|
if( (*next)->getType() != BallLarusEdge::BACKEDGE && // no backedges
|
|
(*next)->getType() != BallLarusEdge::SPLITEDGE && // no split edges
|
|
(*next)->getWeight() <= pathNumber && // weight must be <= pathNumber
|
|
(!best || (best->getWeight() < (*next)->getWeight())) ) // best one?
|
|
best = *next;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
ProfilePathEdgeVector* ProfilePath::getPathEdges() const {
|
|
BallLarusNode* currentNode = _ppi->_currentDag->getRoot ();
|
|
unsigned int increment = _number;
|
|
ProfilePathEdgeVector* pev = new ProfilePathEdgeVector;
|
|
|
|
while (currentNode != _ppi->_currentDag->getExit()) {
|
|
BallLarusEdge* next = getNextEdge(currentNode, increment);
|
|
|
|
increment -= next->getWeight();
|
|
|
|
if( next->getType() != BallLarusEdge::BACKEDGE_PHONY &&
|
|
next->getType() != BallLarusEdge::SPLITEDGE_PHONY &&
|
|
next->getTarget() != _ppi->_currentDag->getExit() )
|
|
pev->push_back(ProfilePathEdge(
|
|
next->getSource()->getBlock(),
|
|
next->getTarget()->getBlock(),
|
|
next->getDuplicateNumber()));
|
|
|
|
if( next->getType() == BallLarusEdge::BACKEDGE_PHONY &&
|
|
next->getTarget() == _ppi->_currentDag->getExit() )
|
|
pev->push_back(ProfilePathEdge(
|
|
next->getRealEdge()->getSource()->getBlock(),
|
|
next->getRealEdge()->getTarget()->getBlock(),
|
|
next->getDuplicateNumber()));
|
|
|
|
if( next->getType() == BallLarusEdge::SPLITEDGE_PHONY &&
|
|
next->getSource() == _ppi->_currentDag->getRoot() )
|
|
pev->push_back(ProfilePathEdge(
|
|
next->getRealEdge()->getSource()->getBlock(),
|
|
next->getRealEdge()->getTarget()->getBlock(),
|
|
next->getDuplicateNumber()));
|
|
|
|
// set the new node
|
|
currentNode = next->getTarget();
|
|
}
|
|
|
|
return pev;
|
|
}
|
|
|
|
ProfilePathBlockVector* ProfilePath::getPathBlocks() const {
|
|
BallLarusNode* currentNode = _ppi->_currentDag->getRoot ();
|
|
unsigned int increment = _number;
|
|
ProfilePathBlockVector* pbv = new ProfilePathBlockVector;
|
|
|
|
while (currentNode != _ppi->_currentDag->getExit()) {
|
|
BallLarusEdge* next = getNextEdge(currentNode, increment);
|
|
increment -= next->getWeight();
|
|
|
|
// add block to the block list if it is a real edge
|
|
if( next->getType() == BallLarusEdge::NORMAL)
|
|
pbv->push_back (currentNode->getBlock());
|
|
// make the back edge the last edge since we are at the end
|
|
else if( next->getTarget() == _ppi->_currentDag->getExit() ) {
|
|
pbv->push_back (currentNode->getBlock());
|
|
pbv->push_back (next->getRealEdge()->getTarget()->getBlock());
|
|
}
|
|
|
|
// set the new node
|
|
currentNode = next->getTarget();
|
|
}
|
|
|
|
return pbv;
|
|
}
|
|
|
|
BasicBlock* ProfilePath::getFirstBlockInPath() const {
|
|
BallLarusNode* root = _ppi->_currentDag->getRoot();
|
|
BallLarusEdge* edge = getNextEdge(root, _number);
|
|
|
|
if( edge && (edge->getType() == BallLarusEdge::BACKEDGE_PHONY ||
|
|
edge->getType() == BallLarusEdge::SPLITEDGE_PHONY) )
|
|
return edge->getTarget()->getBlock();
|
|
|
|
return root->getBlock();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// PathProfileInfo implementation
|
|
//
|
|
|
|
// Pass identification
|
|
char llvm::PathProfileInfo::ID = 0;
|
|
|
|
PathProfileInfo::PathProfileInfo () : _currentDag(0) , _currentFunction(0) {
|
|
}
|
|
|
|
PathProfileInfo::~PathProfileInfo() {
|
|
if (_currentDag)
|
|
delete _currentDag;
|
|
}
|
|
|
|
// set the function for which paths are currently begin processed
|
|
void PathProfileInfo::setCurrentFunction(Function* F) {
|
|
// Make sure it exists
|
|
if (!F) return;
|
|
|
|
if (_currentDag)
|
|
delete _currentDag;
|
|
|
|
_currentFunction = F;
|
|
_currentDag = new BallLarusDag(*F);
|
|
_currentDag->init();
|
|
_currentDag->calculatePathNumbers();
|
|
}
|
|
|
|
// get the function for which paths are currently being processed
|
|
Function* PathProfileInfo::getCurrentFunction() const {
|
|
return _currentFunction;
|
|
}
|
|
|
|
// get the entry block of the function
|
|
BasicBlock* PathProfileInfo::getCurrentFunctionEntry() {
|
|
return _currentDag->getRoot()->getBlock();
|
|
}
|
|
|
|
// return the path based on its number
|
|
ProfilePath* PathProfileInfo::getPath(unsigned int number) {
|
|
return _functionPaths[_currentFunction][number];
|
|
}
|
|
|
|
// return the number of paths which a function may potentially execute
|
|
unsigned int PathProfileInfo::getPotentialPathCount() {
|
|
return _currentDag ? _currentDag->getNumberOfPaths() : 0;
|
|
}
|
|
|
|
// return an iterator for the beginning of a functions executed paths
|
|
ProfilePathIterator PathProfileInfo::pathBegin() {
|
|
return _functionPaths[_currentFunction].begin();
|
|
}
|
|
|
|
// return an iterator for the end of a functions executed paths
|
|
ProfilePathIterator PathProfileInfo::pathEnd() {
|
|
return _functionPaths[_currentFunction].end();
|
|
}
|
|
|
|
// returns the total number of paths run in the function
|
|
unsigned int PathProfileInfo::pathsRun() {
|
|
return _currentFunction ? _functionPaths[_currentFunction].size() : 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// PathLoader implementation
|
|
//
|
|
|
|
// remove all generated paths
|
|
PathProfileLoaderPass::~PathProfileLoaderPass() {
|
|
for( FunctionPathIterator funcNext = _functionPaths.begin(),
|
|
funcEnd = _functionPaths.end(); funcNext != funcEnd; funcNext++)
|
|
for( ProfilePathIterator pathNext = funcNext->second.begin(),
|
|
pathEnd = funcNext->second.end(); pathNext != pathEnd; pathNext++)
|
|
delete pathNext->second;
|
|
}
|
|
|
|
// entry point of the pass; this loads and parses a file
|
|
bool PathProfileLoaderPass::runOnModule(Module &M) {
|
|
// get the filename and setup the module's function references
|
|
_filename = PathProfileInfoFilename;
|
|
buildFunctionRefs (M);
|
|
|
|
if (!(_file = fopen(_filename.c_str(), "rb"))) {
|
|
errs () << "error: input '" << _filename << "' file does not exist.\n";
|
|
return false;
|
|
}
|
|
|
|
ProfilingType profType;
|
|
|
|
while( fread(&profType, sizeof(ProfilingType), 1, _file) ) {
|
|
switch (profType) {
|
|
case ArgumentInfo:
|
|
handleArgumentInfo ();
|
|
break;
|
|
case PathInfo:
|
|
handlePathInfo ();
|
|
break;
|
|
default:
|
|
errs () << "error: bad path profiling file syntax, " << profType << "\n";
|
|
fclose (_file);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
fclose (_file);
|
|
|
|
return true;
|
|
}
|
|
|
|
// create a reference table for functions defined in the path profile file
|
|
void PathProfileLoaderPass::buildFunctionRefs (Module &M) {
|
|
_functions.push_back(0); // make the 0 index a null pointer
|
|
|
|
for (Module::iterator F = M.begin(), E = M.end(); F != E; F++) {
|
|
if (F->isDeclaration())
|
|
continue;
|
|
_functions.push_back(F);
|
|
}
|
|
}
|
|
|
|
// handle command like argument infor in the output file
|
|
void PathProfileLoaderPass::handleArgumentInfo() {
|
|
// get the argument list's length
|
|
unsigned savedArgsLength;
|
|
if( fread(&savedArgsLength, sizeof(unsigned), 1, _file) != 1 ) {
|
|
errs() << "warning: argument info header/data mismatch\n";
|
|
return;
|
|
}
|
|
|
|
// allocate a buffer, and get the arguments
|
|
char* args = new char[savedArgsLength+1];
|
|
if( fread(args, 1, savedArgsLength, _file) != savedArgsLength )
|
|
errs() << "warning: argument info header/data mismatch\n";
|
|
|
|
args[savedArgsLength] = '\0';
|
|
argList = std::string(args);
|
|
delete [] args; // cleanup dynamic string
|
|
|
|
// byte alignment
|
|
if (savedArgsLength & 3)
|
|
fseek(_file, 4-(savedArgsLength&3), SEEK_CUR);
|
|
}
|
|
|
|
// Handle path profile information in the output file
|
|
void PathProfileLoaderPass::handlePathInfo () {
|
|
// get the number of functions in this profile
|
|
unsigned functionCount;
|
|
if( fread(&functionCount, sizeof(functionCount), 1, _file) != 1 ) {
|
|
errs() << "warning: path info header/data mismatch\n";
|
|
return;
|
|
}
|
|
|
|
// gather path information for each function
|
|
for (unsigned i = 0; i < functionCount; i++) {
|
|
PathProfileHeader pathHeader;
|
|
if( fread(&pathHeader, sizeof(pathHeader), 1, _file) != 1 ) {
|
|
errs() << "warning: bad header for path function info\n";
|
|
break;
|
|
}
|
|
|
|
Function* f = _functions[pathHeader.fnNumber];
|
|
|
|
// dynamically allocate a table to store path numbers
|
|
PathProfileTableEntry* pathTable =
|
|
new PathProfileTableEntry[pathHeader.numEntries];
|
|
|
|
if( fread(pathTable, sizeof(PathProfileTableEntry),
|
|
pathHeader.numEntries, _file) != pathHeader.numEntries) {
|
|
delete [] pathTable;
|
|
errs() << "warning: path function info header/data mismatch\n";
|
|
return;
|
|
}
|
|
|
|
// Build a new path for the current function
|
|
unsigned int totalPaths = 0;
|
|
for (unsigned int j = 0; j < pathHeader.numEntries; j++) {
|
|
totalPaths += pathTable[j].pathCounter;
|
|
_functionPaths[f][pathTable[j].pathNumber]
|
|
= new ProfilePath(pathTable[j].pathNumber, pathTable[j].pathCounter,
|
|
0, this);
|
|
}
|
|
|
|
_functionPathCounts[f] = totalPaths;
|
|
|
|
delete [] pathTable;
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// NoProfile PathProfileInfo implementation
|
|
//
|
|
|
|
namespace {
|
|
struct NoPathProfileInfo : public ImmutablePass, public PathProfileInfo {
|
|
static char ID; // Class identification, replacement for typeinfo
|
|
NoPathProfileInfo() : ImmutablePass(ID) {
|
|
initializeNoPathProfileInfoPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
/// getAdjustedAnalysisPointer - This method is used when a pass implements
|
|
/// an analysis interface through multiple inheritance. If needed, it
|
|
/// should override this to adjust the this pointer as needed for the
|
|
/// specified pass info.
|
|
virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
|
|
if (PI == &PathProfileInfo::ID)
|
|
return (PathProfileInfo*)this;
|
|
return this;
|
|
}
|
|
|
|
virtual const char *getPassName() const {
|
|
return "NoPathProfileInfo";
|
|
}
|
|
};
|
|
} // End of anonymous namespace
|
|
|
|
char NoPathProfileInfo::ID = 0;
|
|
// Register this pass...
|
|
INITIALIZE_AG_PASS(NoPathProfileInfo, PathProfileInfo, "no-path-profile",
|
|
"No Path Profile Information", false, true, true)
|
|
|
|
ImmutablePass *llvm::createNoPathProfileInfoPass() { return new NoPathProfileInfo(); }
|