mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-20 19:42:54 +02:00
8f412fadf2
Many of our loop passes make use of so called "must execute" or "guaranteed to execute" facts to prove the legality of code motion. The basic notion is that we know (by assumption) an instruction didn't fault at it's original location, so if the location we move it to is strictly post dominated by the original, then we can't have introduced a new fault. At the moment, the testing for this logic is somewhat adhoc and done mostly through LICM. Since I'm working on that code, I want to improve the testing. This patch is the first step in that direction. It doesn't actually test the variant used by the loop passes - I need to move that to the Analysis library first - but instead exercises an alternate implementation used by SCEV. (I plan on merging both implementations.) Note: I'll be replacing the printing logic within this with an annotation based version in the near future. Anna suggested this in review, and it seems like a strictly better format. Differential Revision: https://reviews.llvm.org/D44524 llvm-svn: 328004
136 lines
5.0 KiB
C++
136 lines
5.0 KiB
C++
//===-- Analysis.cpp ------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm-c/Analysis.h"
|
|
#include "llvm-c/Initialization.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/Verifier.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/PassRegistry.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cstring>
|
|
|
|
using namespace llvm;
|
|
|
|
/// initializeAnalysis - Initialize all passes linked into the Analysis library.
|
|
void llvm::initializeAnalysis(PassRegistry &Registry) {
|
|
initializeAAEvalLegacyPassPass(Registry);
|
|
initializeAliasSetPrinterPass(Registry);
|
|
initializeBasicAAWrapperPassPass(Registry);
|
|
initializeBlockFrequencyInfoWrapperPassPass(Registry);
|
|
initializeBranchProbabilityInfoWrapperPassPass(Registry);
|
|
initializeCallGraphWrapperPassPass(Registry);
|
|
initializeCallGraphDOTPrinterPass(Registry);
|
|
initializeCallGraphPrinterLegacyPassPass(Registry);
|
|
initializeCallGraphViewerPass(Registry);
|
|
initializeCostModelAnalysisPass(Registry);
|
|
initializeCFGViewerLegacyPassPass(Registry);
|
|
initializeCFGPrinterLegacyPassPass(Registry);
|
|
initializeCFGOnlyViewerLegacyPassPass(Registry);
|
|
initializeCFGOnlyPrinterLegacyPassPass(Registry);
|
|
initializeCFLAndersAAWrapperPassPass(Registry);
|
|
initializeCFLSteensAAWrapperPassPass(Registry);
|
|
initializeDependenceAnalysisWrapperPassPass(Registry);
|
|
initializeDelinearizationPass(Registry);
|
|
initializeDemandedBitsWrapperPassPass(Registry);
|
|
initializeDivergenceAnalysisPass(Registry);
|
|
initializeDominanceFrontierWrapperPassPass(Registry);
|
|
initializeDomViewerPass(Registry);
|
|
initializeDomPrinterPass(Registry);
|
|
initializeDomOnlyViewerPass(Registry);
|
|
initializePostDomViewerPass(Registry);
|
|
initializeDomOnlyPrinterPass(Registry);
|
|
initializePostDomPrinterPass(Registry);
|
|
initializePostDomOnlyViewerPass(Registry);
|
|
initializePostDomOnlyPrinterPass(Registry);
|
|
initializeAAResultsWrapperPassPass(Registry);
|
|
initializeGlobalsAAWrapperPassPass(Registry);
|
|
initializeIVUsersWrapperPassPass(Registry);
|
|
initializeInstCountPass(Registry);
|
|
initializeIntervalPartitionPass(Registry);
|
|
initializeLazyBranchProbabilityInfoPassPass(Registry);
|
|
initializeLazyBlockFrequencyInfoPassPass(Registry);
|
|
initializeLazyValueInfoWrapperPassPass(Registry);
|
|
initializeLazyValueInfoPrinterPass(Registry);
|
|
initializeLintPass(Registry);
|
|
initializeLoopInfoWrapperPassPass(Registry);
|
|
initializeMemDepPrinterPass(Registry);
|
|
initializeMemDerefPrinterPass(Registry);
|
|
initializeMemoryDependenceWrapperPassPass(Registry);
|
|
initializeModuleDebugInfoPrinterPass(Registry);
|
|
initializeModuleSummaryIndexWrapperPassPass(Registry);
|
|
initializeMustExecutePrinterPass(Registry);
|
|
initializeObjCARCAAWrapperPassPass(Registry);
|
|
initializeOptimizationRemarkEmitterWrapperPassPass(Registry);
|
|
initializePostDominatorTreeWrapperPassPass(Registry);
|
|
initializeRegionInfoPassPass(Registry);
|
|
initializeRegionViewerPass(Registry);
|
|
initializeRegionPrinterPass(Registry);
|
|
initializeRegionOnlyViewerPass(Registry);
|
|
initializeRegionOnlyPrinterPass(Registry);
|
|
initializeSCEVAAWrapperPassPass(Registry);
|
|
initializeScalarEvolutionWrapperPassPass(Registry);
|
|
initializeTargetTransformInfoWrapperPassPass(Registry);
|
|
initializeTypeBasedAAWrapperPassPass(Registry);
|
|
initializeScopedNoAliasAAWrapperPassPass(Registry);
|
|
initializeLCSSAVerificationPassPass(Registry);
|
|
initializeMemorySSAWrapperPassPass(Registry);
|
|
initializeMemorySSAPrinterLegacyPassPass(Registry);
|
|
}
|
|
|
|
void LLVMInitializeAnalysis(LLVMPassRegistryRef R) {
|
|
initializeAnalysis(*unwrap(R));
|
|
}
|
|
|
|
void LLVMInitializeIPA(LLVMPassRegistryRef R) {
|
|
initializeAnalysis(*unwrap(R));
|
|
}
|
|
|
|
LLVMBool LLVMVerifyModule(LLVMModuleRef M, LLVMVerifierFailureAction Action,
|
|
char **OutMessages) {
|
|
raw_ostream *DebugOS = Action != LLVMReturnStatusAction ? &errs() : nullptr;
|
|
std::string Messages;
|
|
raw_string_ostream MsgsOS(Messages);
|
|
|
|
LLVMBool Result = verifyModule(*unwrap(M), OutMessages ? &MsgsOS : DebugOS);
|
|
|
|
// Duplicate the output to stderr.
|
|
if (DebugOS && OutMessages)
|
|
*DebugOS << MsgsOS.str();
|
|
|
|
if (Action == LLVMAbortProcessAction && Result)
|
|
report_fatal_error("Broken module found, compilation aborted!");
|
|
|
|
if (OutMessages)
|
|
*OutMessages = strdup(MsgsOS.str().c_str());
|
|
|
|
return Result;
|
|
}
|
|
|
|
LLVMBool LLVMVerifyFunction(LLVMValueRef Fn, LLVMVerifierFailureAction Action) {
|
|
LLVMBool Result = verifyFunction(
|
|
*unwrap<Function>(Fn), Action != LLVMReturnStatusAction ? &errs()
|
|
: nullptr);
|
|
|
|
if (Action == LLVMAbortProcessAction && Result)
|
|
report_fatal_error("Broken function found, compilation aborted!");
|
|
|
|
return Result;
|
|
}
|
|
|
|
void LLVMViewFunctionCFG(LLVMValueRef Fn) {
|
|
Function *F = unwrap<Function>(Fn);
|
|
F->viewCFG();
|
|
}
|
|
|
|
void LLVMViewFunctionCFGOnly(LLVMValueRef Fn) {
|
|
Function *F = unwrap<Function>(Fn);
|
|
F->viewCFGOnly();
|
|
}
|