mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 03:33:20 +01:00
e78a008dd1
Summary:
Add a RemoveRedundantDbgInstrs to BasicBlockUtils with the
goal to remove redundant dbg intrinsics from a basic block.
This can be useful after various transforms, as it might
be simpler to do a filtering of dbg intrinsics after the
transform than during the transform.
One primary use case would be to replace a too aggressive
removal done by MergeBlockIntoPredecessor, seen at loop
rotate (not done in this patch).
The elimination algorithm currently focuses on dbg.value
intrinsics and is doing two iterations over the BB.
First we iterate backward starting at the last instruction
in the BB. Whenever a consecutive sequence of dbg.value
instructions are found we keep the last dbg.value for
each variable found (variable fragments are identified
using the {DILocalVariable, FragmentInfo, inlinedAt}
triple as given by the DebugVariable helper class).
Next we iterate forward starting at the first instruction
in the BB. Whenever we find a dbg.value describing a
DebugVariable (identified by {DILocalVariable, inlinedAt})
we save the {DIValue, DIExpression} that describes that
variables value. But if the variable already was mapped
to the same {DIValue, DIExpression} pair we instead drop
the second dbg.value.
To ease the process of making lit tests for this utility a
new pass is introduced called RedundantDbgInstElimination.
It can be executed by opt using -redundant-dbg-inst-elim.
Reviewers: aprantl, jmorse, vsk
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D71478
301 lines
10 KiB
C++
301 lines
10 KiB
C++
//===-- Scalar.cpp --------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements common infrastructure for libLLVMScalarOpts.a, which
|
|
// implements several scalar transformations over the LLVM intermediate
|
|
// representation, including the C bindings for that library.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "llvm-c/Initialization.h"
|
|
#include "llvm-c/Transforms/Scalar.h"
|
|
#include "llvm/Analysis/BasicAliasAnalysis.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/Analysis/ScopedNoAliasAA.h"
|
|
#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
|
|
#include "llvm/IR/DataLayout.h"
|
|
#include "llvm/IR/LegacyPassManager.h"
|
|
#include "llvm/IR/Verifier.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/Transforms/Scalar/GVN.h"
|
|
#include "llvm/Transforms/Scalar/Scalarizer.h"
|
|
#include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
|
|
#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
|
|
|
|
using namespace llvm;
|
|
|
|
/// initializeScalarOptsPasses - Initialize all passes linked into the
|
|
/// ScalarOpts library.
|
|
void llvm::initializeScalarOpts(PassRegistry &Registry) {
|
|
initializeADCELegacyPassPass(Registry);
|
|
initializeBDCELegacyPassPass(Registry);
|
|
initializeAlignmentFromAssumptionsPass(Registry);
|
|
initializeCallSiteSplittingLegacyPassPass(Registry);
|
|
initializeConstantHoistingLegacyPassPass(Registry);
|
|
initializeConstantPropagationPass(Registry);
|
|
initializeCorrelatedValuePropagationPass(Registry);
|
|
initializeDCELegacyPassPass(Registry);
|
|
initializeDeadInstEliminationPass(Registry);
|
|
initializeDivRemPairsLegacyPassPass(Registry);
|
|
initializeScalarizerLegacyPassPass(Registry);
|
|
initializeDSELegacyPassPass(Registry);
|
|
initializeGuardWideningLegacyPassPass(Registry);
|
|
initializeLoopGuardWideningLegacyPassPass(Registry);
|
|
initializeGVNLegacyPassPass(Registry);
|
|
initializeNewGVNLegacyPassPass(Registry);
|
|
initializeEarlyCSELegacyPassPass(Registry);
|
|
initializeEarlyCSEMemSSALegacyPassPass(Registry);
|
|
initializeMakeGuardsExplicitLegacyPassPass(Registry);
|
|
initializeGVNHoistLegacyPassPass(Registry);
|
|
initializeGVNSinkLegacyPassPass(Registry);
|
|
initializeFlattenCFGPassPass(Registry);
|
|
initializeIRCELegacyPassPass(Registry);
|
|
initializeIndVarSimplifyLegacyPassPass(Registry);
|
|
initializeInferAddressSpacesPass(Registry);
|
|
initializeInstSimplifyLegacyPassPass(Registry);
|
|
initializeJumpThreadingPass(Registry);
|
|
initializeLegacyLICMPassPass(Registry);
|
|
initializeLegacyLoopSinkPassPass(Registry);
|
|
initializeLoopFuseLegacyPass(Registry);
|
|
initializeLoopDataPrefetchLegacyPassPass(Registry);
|
|
initializeLoopDeletionLegacyPassPass(Registry);
|
|
initializeLoopAccessLegacyAnalysisPass(Registry);
|
|
initializeLoopInstSimplifyLegacyPassPass(Registry);
|
|
initializeLoopInterchangePass(Registry);
|
|
initializeLoopPredicationLegacyPassPass(Registry);
|
|
initializeLoopRotateLegacyPassPass(Registry);
|
|
initializeLoopStrengthReducePass(Registry);
|
|
initializeLoopRerollPass(Registry);
|
|
initializeLoopUnrollPass(Registry);
|
|
initializeLoopUnrollAndJamPass(Registry);
|
|
initializeLoopUnswitchPass(Registry);
|
|
initializeWarnMissedTransformationsLegacyPass(Registry);
|
|
initializeLoopVersioningLICMPass(Registry);
|
|
initializeLoopIdiomRecognizeLegacyPassPass(Registry);
|
|
initializeLowerAtomicLegacyPassPass(Registry);
|
|
initializeLowerConstantIntrinsicsPass(Registry);
|
|
initializeLowerExpectIntrinsicPass(Registry);
|
|
initializeLowerGuardIntrinsicLegacyPassPass(Registry);
|
|
initializeLowerMatrixIntrinsicsLegacyPassPass(Registry);
|
|
initializeLowerWidenableConditionLegacyPassPass(Registry);
|
|
initializeMemCpyOptLegacyPassPass(Registry);
|
|
initializeMergeICmpsLegacyPassPass(Registry);
|
|
initializeMergedLoadStoreMotionLegacyPassPass(Registry);
|
|
initializeNaryReassociateLegacyPassPass(Registry);
|
|
initializePartiallyInlineLibCallsLegacyPassPass(Registry);
|
|
initializeReassociateLegacyPassPass(Registry);
|
|
initializeRedundantDbgInstEliminationPass(Registry);
|
|
initializeRegToMemPass(Registry);
|
|
initializeRewriteStatepointsForGCLegacyPassPass(Registry);
|
|
initializeSCCPLegacyPassPass(Registry);
|
|
initializeSROALegacyPassPass(Registry);
|
|
initializeCFGSimplifyPassPass(Registry);
|
|
initializeStructurizeCFGPass(Registry);
|
|
initializeSimpleLoopUnswitchLegacyPassPass(Registry);
|
|
initializeSinkingLegacyPassPass(Registry);
|
|
initializeTailCallElimPass(Registry);
|
|
initializeSeparateConstOffsetFromGEPPass(Registry);
|
|
initializeSpeculativeExecutionLegacyPassPass(Registry);
|
|
initializeStraightLineStrengthReducePass(Registry);
|
|
initializePlaceBackedgeSafepointsImplPass(Registry);
|
|
initializePlaceSafepointsPass(Registry);
|
|
initializeFloat2IntLegacyPassPass(Registry);
|
|
initializeLoopDistributeLegacyPass(Registry);
|
|
initializeLoopLoadEliminationPass(Registry);
|
|
initializeLoopSimplifyCFGLegacyPassPass(Registry);
|
|
initializeLoopVersioningPassPass(Registry);
|
|
initializeEntryExitInstrumenterPass(Registry);
|
|
initializePostInlineEntryExitInstrumenterPass(Registry);
|
|
}
|
|
|
|
void LLVMAddLoopSimplifyCFGPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopSimplifyCFGPass());
|
|
}
|
|
|
|
void LLVMInitializeScalarOpts(LLVMPassRegistryRef R) {
|
|
initializeScalarOpts(*unwrap(R));
|
|
}
|
|
|
|
void LLVMAddAggressiveDCEPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createAggressiveDCEPass());
|
|
}
|
|
|
|
void LLVMAddDCEPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createDeadCodeEliminationPass());
|
|
}
|
|
|
|
void LLVMAddBitTrackingDCEPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createBitTrackingDCEPass());
|
|
}
|
|
|
|
void LLVMAddAlignmentFromAssumptionsPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createAlignmentFromAssumptionsPass());
|
|
}
|
|
|
|
void LLVMAddCFGSimplificationPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createCFGSimplificationPass(1, false, false, true));
|
|
}
|
|
|
|
void LLVMAddDeadStoreEliminationPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createDeadStoreEliminationPass());
|
|
}
|
|
|
|
void LLVMAddScalarizerPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createScalarizerPass());
|
|
}
|
|
|
|
void LLVMAddGVNPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createGVNPass());
|
|
}
|
|
|
|
void LLVMAddNewGVNPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createNewGVNPass());
|
|
}
|
|
|
|
void LLVMAddMergedLoadStoreMotionPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createMergedLoadStoreMotionPass());
|
|
}
|
|
|
|
void LLVMAddIndVarSimplifyPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createIndVarSimplifyPass());
|
|
}
|
|
|
|
void LLVMAddJumpThreadingPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createJumpThreadingPass());
|
|
}
|
|
|
|
void LLVMAddLoopSinkPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopSinkPass());
|
|
}
|
|
|
|
void LLVMAddLICMPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLICMPass());
|
|
}
|
|
|
|
void LLVMAddLoopDeletionPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopDeletionPass());
|
|
}
|
|
|
|
void LLVMAddLoopIdiomPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopIdiomPass());
|
|
}
|
|
|
|
void LLVMAddLoopRotatePass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopRotatePass());
|
|
}
|
|
|
|
void LLVMAddLoopRerollPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopRerollPass());
|
|
}
|
|
|
|
void LLVMAddLoopUnrollPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopUnrollPass());
|
|
}
|
|
|
|
void LLVMAddLoopUnrollAndJamPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopUnrollAndJamPass());
|
|
}
|
|
|
|
void LLVMAddLoopUnswitchPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLoopUnswitchPass());
|
|
}
|
|
|
|
void LLVMAddLowerAtomicPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLowerAtomicPass());
|
|
}
|
|
|
|
void LLVMAddMemCpyOptPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createMemCpyOptPass());
|
|
}
|
|
|
|
void LLVMAddPartiallyInlineLibCallsPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createPartiallyInlineLibCallsPass());
|
|
}
|
|
|
|
void LLVMAddReassociatePass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createReassociatePass());
|
|
}
|
|
|
|
void LLVMAddSCCPPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createSCCPPass());
|
|
}
|
|
|
|
void LLVMAddScalarReplAggregatesPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createSROAPass());
|
|
}
|
|
|
|
void LLVMAddScalarReplAggregatesPassSSA(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createSROAPass());
|
|
}
|
|
|
|
void LLVMAddScalarReplAggregatesPassWithThreshold(LLVMPassManagerRef PM,
|
|
int Threshold) {
|
|
unwrap(PM)->add(createSROAPass());
|
|
}
|
|
|
|
void LLVMAddSimplifyLibCallsPass(LLVMPassManagerRef PM) {
|
|
// NOTE: The simplify-libcalls pass has been removed.
|
|
}
|
|
|
|
void LLVMAddTailCallEliminationPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createTailCallEliminationPass());
|
|
}
|
|
|
|
void LLVMAddConstantPropagationPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createConstantPropagationPass());
|
|
}
|
|
|
|
void LLVMAddDemoteMemoryToRegisterPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createDemoteRegisterToMemoryPass());
|
|
}
|
|
|
|
void LLVMAddVerifierPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createVerifierPass());
|
|
}
|
|
|
|
void LLVMAddCorrelatedValuePropagationPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createCorrelatedValuePropagationPass());
|
|
}
|
|
|
|
void LLVMAddEarlyCSEPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createEarlyCSEPass(false/*=UseMemorySSA*/));
|
|
}
|
|
|
|
void LLVMAddEarlyCSEMemSSAPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createEarlyCSEPass(true/*=UseMemorySSA*/));
|
|
}
|
|
|
|
void LLVMAddGVNHoistLegacyPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createGVNHoistPass());
|
|
}
|
|
|
|
void LLVMAddTypeBasedAliasAnalysisPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createTypeBasedAAWrapperPass());
|
|
}
|
|
|
|
void LLVMAddScopedNoAliasAAPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createScopedNoAliasAAWrapperPass());
|
|
}
|
|
|
|
void LLVMAddBasicAliasAnalysisPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createBasicAAWrapperPass());
|
|
}
|
|
|
|
void LLVMAddLowerConstantIntrinsicsPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLowerConstantIntrinsicsPass());
|
|
}
|
|
|
|
void LLVMAddLowerExpectIntrinsicPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createLowerExpectIntrinsicPass());
|
|
}
|
|
|
|
void LLVMAddUnifyFunctionExitNodesPass(LLVMPassManagerRef PM) {
|
|
unwrap(PM)->add(createUnifyFunctionExitNodesPass());
|
|
}
|