mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-04-05 01:01:45 +00:00
dad102bcc9
analyses to have a common type which is enforced rather than using a char object and a `void *` type when used as an identifier. This has a number of advantages. First, it at least helps some of the confusion raised in Justin Lebar's code review of why `void *` was being used everywhere by having a stronger type that connects to documentation about this. However, perhaps more importantly, it addresses a serious issue where the alignment of these pointer-like identifiers was unknown. This made it hard to use them in pointer-like data structures. We were already dodging this in dangerous ways to create the "all analyses" entry. In a subsequent patch I attempted to use these with TinyPtrVector and things fell apart in a very bad way. And it isn't just a compile time or type system issue. Worse than that, the actual alignment of these pointer-like opaque identifiers wasn't guaranteed to be a useful alignment as they were just characters. This change introduces a type to use as the "key" object whose address forms the opaque identifier. This both forces the objects to have proper alignment, and provides type checking that we get it right everywhere. It also makes the types somewhat less mysterious than `void *`. We could go one step further and introduce a truly opaque pointer-like type to return from the `ID()` static function rather than returning `AnalysisKey *`, but that didn't seem to be a clear win so this is just the initial change to get to a reliably typed and aligned object serving is a key for all the analyses. Thanks to Richard Smith and Justin Lebar for helping pick plausible names and avoid making this refactoring many times. =] And thanks to Sean for the super fast review! While here, I've tried to move away from the "PassID" nomenclature entirely as it wasn't really helping and is overloaded with old pass manager constructs. Now we have IDs for analyses, and key objects whose address can be used as IDs. Where possible and clear I've shortened this to just "ID". In a few places I kept "AnalysisID" to make it clear what was being identified. Differential Revision: https://reviews.llvm.org/D27031 llvm-svn: 287783
76 lines
2.4 KiB
C++
76 lines
2.4 KiB
C++
//===- ModuleSummaryAnalysis.h - Module summary index builder ---*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This is the interface to build a ModuleSummaryIndex for a module.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_MODULESUMMARYANALYSIS_H
|
|
#define LLVM_ANALYSIS_MODULESUMMARYANALYSIS_H
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/IR/ModuleSummaryIndex.h"
|
|
#include "llvm/IR/PassManager.h"
|
|
#include "llvm/Pass.h"
|
|
|
|
namespace llvm {
|
|
class BlockFrequencyInfo;
|
|
class ProfileSummaryInfo;
|
|
|
|
/// Direct function to compute a \c ModuleSummaryIndex from a given module.
|
|
///
|
|
/// If operating within a pass manager which has defined ways to compute the \c
|
|
/// BlockFrequencyInfo for a given function, that can be provided via
|
|
/// a std::function callback. Otherwise, this routine will manually construct
|
|
/// that information.
|
|
ModuleSummaryIndex buildModuleSummaryIndex(
|
|
const Module &M,
|
|
std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
|
|
ProfileSummaryInfo *PSI);
|
|
|
|
/// Analysis pass to provide the ModuleSummaryIndex object.
|
|
class ModuleSummaryIndexAnalysis
|
|
: public AnalysisInfoMixin<ModuleSummaryIndexAnalysis> {
|
|
friend AnalysisInfoMixin<ModuleSummaryIndexAnalysis>;
|
|
static AnalysisKey Key;
|
|
|
|
public:
|
|
typedef ModuleSummaryIndex Result;
|
|
|
|
Result run(Module &M, ModuleAnalysisManager &AM);
|
|
};
|
|
|
|
/// Legacy wrapper pass to provide the ModuleSummaryIndex object.
|
|
class ModuleSummaryIndexWrapperPass : public ModulePass {
|
|
Optional<ModuleSummaryIndex> Index;
|
|
|
|
public:
|
|
static char ID;
|
|
|
|
ModuleSummaryIndexWrapperPass();
|
|
|
|
/// Get the index built by pass
|
|
ModuleSummaryIndex &getIndex() { return *Index; }
|
|
const ModuleSummaryIndex &getIndex() const { return *Index; }
|
|
|
|
bool runOnModule(Module &M) override;
|
|
bool doFinalization(Module &M) override;
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override;
|
|
};
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
//
|
|
// createModuleSummaryIndexWrapperPass - This pass builds a ModuleSummaryIndex
|
|
// object for the module, to be written to bitcode or LLVM assembly.
|
|
//
|
|
ModulePass *createModuleSummaryIndexWrapperPass();
|
|
}
|
|
|
|
#endif
|