mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-02 11:30:10 +00:00
Sooooo many of these had incorrect or strange main module includes. I have manually inspected all of these, and fixed the main module include to be the nearest plausible thing I could find. If you own or care about any of these source files, I encourage you to take some time and check that these edits were sensible. I can't have broken anything (I strictly added headers, and reordered them, never removed), but they may not be the headers you'd really like to identify as containing the API being implemented. Many forward declarations and missing includes were added to a header files to allow them to parse cleanly when included first. The main module rule does in fact have its merits. =] git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@169131 91177308-0d34-0410-b5e6-96231b3b80d8
141 lines
5.0 KiB
C++
141 lines
5.0 KiB
C++
//===- ProfileDataLoader.h - Load & convert profile info ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The ProfileDataLoader class is used to load profiling data from a dump file.
|
|
// The ProfileDataT<FType, BType> class is used to store the mapping of this
|
|
// data to control flow edges.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_PROFILEDATALOADER_H
|
|
#define LLVM_ANALYSIS_PROFILEDATALOADER_H
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include <string>
|
|
|
|
namespace llvm {
|
|
|
|
class ModulePass;
|
|
class Function;
|
|
class BasicBlock;
|
|
|
|
// Helper for dumping edges to dbgs().
|
|
raw_ostream& operator<<(raw_ostream &O, std::pair<const BasicBlock *,
|
|
const BasicBlock *> E);
|
|
|
|
/// \brief The ProfileDataT<FType, BType> class is used to store the mapping of
|
|
/// profiling data to control flow edges.
|
|
///
|
|
/// An edge is defined by its source and sink basic blocks.
|
|
template<class FType, class BType>
|
|
class ProfileDataT {
|
|
public:
|
|
// The profiling information defines an Edge by its source and sink basic
|
|
// blocks.
|
|
typedef std::pair<const BType*, const BType*> Edge;
|
|
|
|
private:
|
|
typedef DenseMap<Edge, unsigned> EdgeWeights;
|
|
|
|
/// \brief Count the number of times a transition between two blocks is
|
|
/// executed.
|
|
///
|
|
/// As a special case, we also hold an edge from the null BasicBlock to the
|
|
/// entry block to indicate how many times the function was entered.
|
|
DenseMap<const FType*, EdgeWeights> EdgeInformation;
|
|
|
|
public:
|
|
/// getFunction() - Returns the Function for an Edge.
|
|
static const FType *getFunction(Edge e) {
|
|
// e.first may be NULL
|
|
assert(((!e.first) || (e.first->getParent() == e.second->getParent()))
|
|
&& "A ProfileData::Edge can not be between two functions");
|
|
assert(e.second && "A ProfileData::Edge must have a real sink");
|
|
return e.second->getParent();
|
|
}
|
|
|
|
/// getEdge() - Creates an Edge between two BasicBlocks.
|
|
static Edge getEdge(const BType *Src, const BType *Dest) {
|
|
return Edge(Src, Dest);
|
|
}
|
|
|
|
/// getEdgeWeight - Return the number of times that a given edge was
|
|
/// executed.
|
|
unsigned getEdgeWeight(Edge e) const {
|
|
const FType *f = getFunction(e);
|
|
assert((EdgeInformation.find(f) != EdgeInformation.end())
|
|
&& "No profiling information for function");
|
|
EdgeWeights weights = EdgeInformation.find(f)->second;
|
|
|
|
assert((weights.find(e) != weights.end())
|
|
&& "No profiling information for edge");
|
|
return weights.find(e)->second;
|
|
}
|
|
|
|
/// addEdgeWeight - Add 'weight' to the already stored execution count for
|
|
/// this edge.
|
|
void addEdgeWeight(Edge e, unsigned weight) {
|
|
EdgeInformation[getFunction(e)][e] += weight;
|
|
}
|
|
};
|
|
|
|
typedef ProfileDataT<Function, BasicBlock> ProfileData;
|
|
//typedef ProfileDataT<MachineFunction, MachineBasicBlock> MachineProfileData;
|
|
|
|
/// The ProfileDataLoader class is used to load raw profiling data from the
|
|
/// dump file.
|
|
class ProfileDataLoader {
|
|
private:
|
|
/// The name of the file where the raw profiling data is stored.
|
|
const std::string &Filename;
|
|
|
|
/// A vector of the command line arguments used when the target program was
|
|
/// run to generate profiling data. One entry per program run.
|
|
SmallVector<std::string, 1> CommandLines;
|
|
|
|
/// The raw values for how many times each edge was traversed, values from
|
|
/// multiple program runs are accumulated.
|
|
SmallVector<unsigned, 32> EdgeCounts;
|
|
|
|
public:
|
|
/// ProfileDataLoader ctor - Read the specified profiling data file, exiting
|
|
/// the program if the file is invalid or broken.
|
|
ProfileDataLoader(const char *ToolName, const std::string &Filename);
|
|
|
|
/// A special value used to represent the weight of an edge which has not
|
|
/// been counted yet.
|
|
static const unsigned Uncounted;
|
|
|
|
/// getNumExecutions - Return the number of times the target program was run
|
|
/// to generate this profiling data.
|
|
unsigned getNumExecutions() const { return CommandLines.size(); }
|
|
|
|
/// getExecution - Return the command line parameters used to generate the
|
|
/// i'th set of profiling data.
|
|
const std::string &getExecution(unsigned i) const { return CommandLines[i]; }
|
|
|
|
const std::string &getFileName() const { return Filename; }
|
|
|
|
/// getRawEdgeCounts - Return the raw profiling data, this is just a list of
|
|
/// numbers with no mappings to edges.
|
|
ArrayRef<unsigned> getRawEdgeCounts() const { return EdgeCounts; }
|
|
};
|
|
|
|
/// createProfileMetadataLoaderPass - This function returns a Pass that loads
|
|
/// the profiling information for the module from the specified filename.
|
|
ModulePass *createProfileMetadataLoaderPass(const std::string &Filename);
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|