[llvm] Revert "[LLVM] Add IRNormalizer Pass" (PR #113392)
Justin Fargnoli via llvm-commits
llvm-commits at lists.llvm.org
Tue Oct 22 15:58:47 PDT 2024
https://github.com/justinfargnoli created https://github.com/llvm/llvm-project/pull/113392
Reverts llvm/llvm-project#68176
>From f40769c2d86c1b8e2b0d6d03209d70782103ae28 Mon Sep 17 00:00:00 2001
From: Justin Fargnoli <jfargnoli at nvidia.com>
Date: Tue, 22 Oct 2024 15:58:31 -0700
Subject: [PATCH] Revert "[LLVM] Add IRNormalizer Pass (#68176)"
This reverts commit 1295d2e6da2fe90f3b770ab1d35bf5caecd38bed.
---
llvm/docs/Passes.rst | 8 -
llvm/docs/ReleaseNotes.md | 5 -
.../llvm/Transforms/Utils/IRNormalizer.h | 15 -
llvm/lib/Passes/PassBuilder.cpp | 1 -
llvm/lib/Passes/PassRegistry.def | 1 -
llvm/lib/Transforms/Utils/CMakeLists.txt | 1 -
llvm/lib/Transforms/Utils/IRNormalizer.cpp | 695 ------------------
.../IRNormalizer/naming-args-instr-blocks.ll | 18 -
.../IRNormalizer/naming-arguments.ll | 13 -
llvm/test/Transforms/IRNormalizer/naming.ll | 30 -
.../regression-convergence-tokens.ll | 27 -
.../regression-coro-elide-musttail.ll | 21 -
.../IRNormalizer/regression-deoptimize.ll | 18 -
.../regression-dont-hoist-deoptimize.ll | 20 -
.../IRNormalizer/regression-infinite-loop.ll | 195 -----
.../IRNormalizer/reordering-basic.ll | 58 --
.../Transforms/IRNormalizer/reordering.ll | 163 ----
17 files changed, 1289 deletions(-)
delete mode 100644 llvm/include/llvm/Transforms/Utils/IRNormalizer.h
delete mode 100644 llvm/lib/Transforms/Utils/IRNormalizer.cpp
delete mode 100644 llvm/test/Transforms/IRNormalizer/naming-args-instr-blocks.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/naming-arguments.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/naming.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/regression-convergence-tokens.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/regression-coro-elide-musttail.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/regression-deoptimize.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/regression-dont-hoist-deoptimize.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/regression-infinite-loop.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/reordering-basic.ll
delete mode 100644 llvm/test/Transforms/IRNormalizer/reordering.ll
diff --git a/llvm/docs/Passes.rst b/llvm/docs/Passes.rst
index 5e436db62be3a1..49f633e98d16fe 100644
--- a/llvm/docs/Passes.rst
+++ b/llvm/docs/Passes.rst
@@ -543,14 +543,6 @@ variables with initializers are marked as internal.
An interprocedural variant of :ref:`Sparse Conditional Constant Propagation
<passes-sccp>`.
-``ir-normalizer``: Transforms IR into a normal form that's easier to diff
-----------------------------------------------------------------------------
-
-This pass aims to transform LLVM Modules into a normal form by reordering and
-renaming instructions while preserving the same semantics. The normalizer makes
-it easier to spot semantic differences while diffing two modules which have
-undergone two different passes.
-
``jump-threading``: Jump Threading
----------------------------------
diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index 0c4cd437dac0b4..c8f5d22c15472a 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -42,11 +42,6 @@ point (e.g. maybe you would like to give an example of the
functionality, or simply have a lot to talk about), see the comment below
for adding a new subsection. -->
-* Added a new IRNormalizer pass which aims to transform LLVM modules into
- a normal form by reordering and renaming instructions while preserving the
- same semantics. The normalizer makes it easier to spot semantic differences
- when diffing two modules which have undergone different passes.
-
* ...
<!-- If you would like to document a larger change, then you can add a
diff --git a/llvm/include/llvm/Transforms/Utils/IRNormalizer.h b/llvm/include/llvm/Transforms/Utils/IRNormalizer.h
deleted file mode 100644
index af1f715d4940d8..00000000000000
--- a/llvm/include/llvm/Transforms/Utils/IRNormalizer.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef LLVM_TRANSFORMS_UTILS_IRNORMALIZER_H
-#define LLVM_TRANSFORMS_UTILS_IRNORMALIZER_H
-
-#include "llvm/IR/PassManager.h"
-
-namespace llvm {
-
-/// IRNormalizer aims to transform LLVM IR into normal form.
-struct IRNormalizerPass : public PassInfoMixin<IRNormalizerPass> {
- PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) const;
-};
-
-} // namespace llvm
-
-#endif // LLVM_TRANSFORMS_UTILS_IRNORMALIZER_H
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 67ebc3015a46df..19e8a96bf78972 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -303,7 +303,6 @@
#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
#include "llvm/Transforms/Utils/FixIrreducible.h"
#include "llvm/Transforms/Utils/HelloWorld.h"
-#include "llvm/Transforms/Utils/IRNormalizer.h"
#include "llvm/Transforms/Utils/InjectTLIMappings.h"
#include "llvm/Transforms/Utils/InstructionNamer.h"
#include "llvm/Transforms/Utils/Instrumentation.h"
diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def
index d1fac824fdcd5f..549c1359b5852c 100644
--- a/llvm/lib/Passes/PassRegistry.def
+++ b/llvm/lib/Passes/PassRegistry.def
@@ -412,7 +412,6 @@ FUNCTION_PASS("move-auto-init", MoveAutoInitPass())
FUNCTION_PASS("nary-reassociate", NaryReassociatePass())
FUNCTION_PASS("newgvn", NewGVNPass())
FUNCTION_PASS("no-op-function", NoOpFunctionPass())
-FUNCTION_PASS("normalize", IRNormalizerPass())
FUNCTION_PASS("objc-arc", ObjCARCOptPass())
FUNCTION_PASS("objc-arc-contract", ObjCARCContractPass())
FUNCTION_PASS("objc-arc-expand", ObjCARCExpandPass())
diff --git a/llvm/lib/Transforms/Utils/CMakeLists.txt b/llvm/lib/Transforms/Utils/CMakeLists.txt
index 65bd3080662c4d..36761cf3569741 100644
--- a/llvm/lib/Transforms/Utils/CMakeLists.txt
+++ b/llvm/lib/Transforms/Utils/CMakeLists.txt
@@ -37,7 +37,6 @@ add_llvm_component_library(LLVMTransformUtils
InstructionNamer.cpp
Instrumentation.cpp
IntegerDivision.cpp
- IRNormalizer.cpp
LCSSA.cpp
LibCallsShrinkWrap.cpp
Local.cpp
diff --git a/llvm/lib/Transforms/Utils/IRNormalizer.cpp b/llvm/lib/Transforms/Utils/IRNormalizer.cpp
deleted file mode 100644
index 74c8fc26a0acd5..00000000000000
--- a/llvm/lib/Transforms/Utils/IRNormalizer.cpp
+++ /dev/null
@@ -1,695 +0,0 @@
-//===--------------- IRNormalizer.cpp - IR Normalizer ---------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-/// \file
-/// This file implements the IRNormalizer class which aims to transform LLVM
-/// Modules into a normal form by reordering and renaming instructions while
-/// preserving the same semantics. The normalizer makes it easier to spot
-/// semantic differences while diffing two modules which have undergone
-/// different passes.
-///
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Transforms/Utils/IRNormalizer.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/InstIterator.h"
-#include "llvm/IR/Module.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
-#include "llvm/PassRegistry.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Transforms/Utils.h"
-#include <algorithm>
-#include <stack>
-
-#define DEBUG_TYPE "normalize"
-
-using namespace llvm;
-
-namespace {
-/// IRNormalizer aims to transform LLVM IR into normal form.
-class IRNormalizer {
-public:
- /// \name Normalizer flags.
- /// @{
- /// Preserves original order of instructions.
- static cl::opt<bool> PreserveOrder;
- /// Renames all instructions (including user-named).
- static cl::opt<bool> RenameAll; // TODO: Don't rename on empty name
- /// Folds all regular instructions (including pre-outputs).
- static cl::opt<bool> FoldPreOutputs;
- /// Sorts and reorders operands in commutative instructions.
- static cl::opt<bool> ReorderOperands;
- /// @}
-
- bool runOnFunction(Function &F);
-
-private:
- // Random constant for hashing, so the state isn't zero.
- const uint64_t MagicHashConstant = 0x6acaa36bef8325c5ULL;
- DenseSet<const Instruction *> NamedInstructions;
-
- SmallVector<Instruction *, 16> Outputs;
-
- /// \name Naming.
- /// @{
- void nameFunctionArguments(Function &F) const;
- void nameBasicBlocks(Function &F) const;
- void nameInstruction(Instruction *I);
- void nameAsInitialInstruction(Instruction *I) const;
- void nameAsRegularInstruction(Instruction *I);
- void foldInstructionName(Instruction *I) const;
- /// @}
-
- /// \name Reordering.
- /// @{
- void reorderInstructions(Function &F) const;
- void reorderDefinition(Instruction *Definition,
- std::stack<Instruction *> &TopologicalSort,
- SmallPtrSet<const Instruction *, 32> &Visited) const;
- void reorderInstructionOperandsByNames(Instruction *I) const;
- void reorderPHIIncomingValues(PHINode *Phi) const;
- /// @}
-
- /// \name Utility methods.
- /// @{
- template <typename T>
- void sortCommutativeOperands(Instruction *I, T &Operands) const;
- SmallVector<Instruction *, 16> collectOutputInstructions(Function &F) const;
- bool isOutput(const Instruction *I) const;
- bool isInitialInstruction(const Instruction *I) const;
- bool hasOnlyImmediateOperands(const Instruction *I) const;
- SetVector<int>
- getOutputFootprint(Instruction *I,
- SmallPtrSet<const Instruction *, 32> &Visited) const;
- /// @}
-};
-} // namespace
-
-cl::opt<bool> IRNormalizer::PreserveOrder(
- "norm-preserve-order", cl::Hidden, cl::init(false),
- cl::desc("Preserves original instruction order"));
-cl::opt<bool> IRNormalizer::RenameAll(
- "norm-rename-all", cl::Hidden, cl::init(true),
- cl::desc("Renames all instructions (including user-named)"));
-cl::opt<bool> IRNormalizer::FoldPreOutputs(
- "norm-fold-all", cl::Hidden, cl::init(true),
- cl::desc("Folds all regular instructions (including pre-outputs)"));
-cl::opt<bool> IRNormalizer::ReorderOperands(
- "norm-reorder-operands", cl::Hidden, cl::init(true),
- cl::desc("Sorts and reorders operands in commutative instructions"));
-
-/// Entry method to the IRNormalizer.
-///
-/// \param F Function to normalize.
-bool IRNormalizer::runOnFunction(Function &F) {
- nameFunctionArguments(F);
- nameBasicBlocks(F);
-
- Outputs = collectOutputInstructions(F);
-
- if (!PreserveOrder)
- reorderInstructions(F);
-
- // TODO: Reorder basic blocks via a topological sort.
-
- for (auto &I : Outputs)
- nameInstruction(I);
-
- for (auto &I : instructions(F)) {
- if (!PreserveOrder) {
- if (ReorderOperands)
- reorderInstructionOperandsByNames(&I);
-
- if (auto *Phi = dyn_cast<PHINode>(&I))
- reorderPHIIncomingValues(Phi);
- }
- foldInstructionName(&I);
- }
-
- return true;
-}
-
-/// Numbers arguments.
-///
-/// \param F Function whose arguments will be renamed.
-void IRNormalizer::nameFunctionArguments(Function &F) const {
- int ArgumentCounter = 0;
- for (auto &A : F.args()) {
- if (RenameAll || A.getName().empty()) {
- A.setName("a" + Twine(ArgumentCounter));
- ArgumentCounter += 1;
- }
- }
-}
-
-/// Names basic blocks using a generated hash for each basic block in
-/// a function considering the opcode and the order of output instructions.
-///
-/// \param F Function containing basic blocks to rename.
-void IRNormalizer::nameBasicBlocks(Function &F) const {
- for (auto &B : F) {
- // Initialize to a magic constant, so the state isn't zero.
- uint64_t Hash = MagicHashConstant;
-
- // Hash considering output instruction opcodes.
- for (auto &I : B)
- if (isOutput(&I))
- Hash = hashing::detail::hash_16_bytes(Hash, I.getOpcode());
-
- if (RenameAll || B.getName().empty()) {
- // Name basic block. Substring hash to make diffs more readable.
- B.setName("bb" + std::to_string(Hash).substr(0, 5));
- }
- }
-}
-
-/// Names instructions graphically (recursive) in accordance with the
-/// def-use tree, starting from the initial instructions (defs), finishing at
-/// the output (top-most user) instructions (depth-first).
-///
-/// \param I Instruction to be renamed.
-void IRNormalizer::nameInstruction(Instruction *I) {
- // Ensure instructions are not renamed. This is done
- // to prevent situation where instructions are used
- // before their definition (in phi nodes)
- if (NamedInstructions.contains(I))
- return;
- NamedInstructions.insert(I);
- if (isInitialInstruction(I)) {
- nameAsInitialInstruction(I);
- } else {
- // This must be a regular instruction.
- nameAsRegularInstruction(I);
- }
-}
-
-template <typename T>
-void IRNormalizer::sortCommutativeOperands(Instruction *I, T &Operands) const {
- if (!(I->isCommutative() && Operands.size() >= 2))
- return;
- auto CommutativeEnd = Operands.begin();
- std::advance(CommutativeEnd, 2);
- llvm::sort(Operands.begin(), CommutativeEnd);
-}
-
-/// Names instruction following the scheme:
-/// vl00000Callee(Operands)
-///
-/// Where 00000 is a hash calculated considering instruction's opcode and output
-/// footprint. Callee's name is only included when instruction's type is
-/// CallInst. In cases where instruction is commutative, operands list is also
-/// sorted.
-///
-/// Renames instruction only when RenameAll flag is raised or instruction is
-/// unnamed.
-///
-/// \see getOutputFootprint()
-/// \param I Instruction to be renamed.
-void IRNormalizer::nameAsInitialInstruction(Instruction *I) const {
- if (I->getType()->isVoidTy())
- return;
- if (!(I->getName().empty() || RenameAll))
- return;
- LLVM_DEBUG(dbgs() << "Naming initial instruction: " << *I << "\n");
-
- // Instruction operands for further sorting.
- SmallVector<SmallString<64>, 4> Operands;
-
- // Collect operands.
- for (auto &Op : I->operands()) {
- if (!isa<Function>(Op)) {
- std::string TextRepresentation;
- raw_string_ostream Stream(TextRepresentation);
- Op->printAsOperand(Stream, false);
- Operands.push_back(StringRef(Stream.str()));
- }
- }
-
- sortCommutativeOperands(I, Operands);
-
- // Initialize to a magic constant, so the state isn't zero.
- uint64_t Hash = MagicHashConstant;
-
- // Consider instruction's opcode in the hash.
- Hash = hashing::detail::hash_16_bytes(Hash, I->getOpcode());
-
- SmallPtrSet<const Instruction *, 32> Visited;
- // Get output footprint for I.
- SetVector<int> OutputFootprint = getOutputFootprint(I, Visited);
-
- // Consider output footprint in the hash.
- for (const int &Output : OutputFootprint)
- Hash = hashing::detail::hash_16_bytes(Hash, Output);
-
- // Base instruction name.
- SmallString<256> Name;
- Name.append("vl" + std::to_string(Hash).substr(0, 5));
-
- // In case of CallInst, consider callee in the instruction name.
- if (const auto *CI = dyn_cast<CallInst>(I)) {
- Function *F = CI->getCalledFunction();
-
- if (F != nullptr)
- Name.append(F->getName());
- }
-
- Name.append("(");
- for (size_t i = 0; i < Operands.size(); ++i) {
- Name.append(Operands[i]);
-
- if (i < Operands.size() - 1)
- Name.append(", ");
- }
- Name.append(")");
-
- I->setName(Name);
-}
-
-/// Names instruction following the scheme:
-/// op00000Callee(Operands)
-///
-/// Where 00000 is a hash calculated considering instruction's opcode, its
-/// operands' opcodes and order. Callee's name is only included when
-/// instruction's type is CallInst. In cases where instruction is commutative,
-/// operand list is also sorted.
-///
-/// Names instructions recursively in accordance with the def-use tree,
-/// starting from the initial instructions (defs), finishing at
-/// the output (top-most user) instructions (depth-first).
-///
-/// Renames instruction only when RenameAll flag is raised or instruction is
-/// unnamed.
-///
-/// \see getOutputFootprint()
-/// \param I Instruction to be renamed.
-void IRNormalizer::nameAsRegularInstruction(Instruction *I) {
- LLVM_DEBUG(dbgs() << "Naming regular instruction: " << *I << "\n");
-
- // Instruction operands for further sorting.
- SmallVector<SmallString<128>, 4> Operands;
-
- // The name of a regular instruction depends
- // on the names of its operands. Hence, all
- // operands must be named first in the use-def
- // walk.
-
- // Collect operands.
- for (auto &Op : I->operands()) {
- if (auto *I = dyn_cast<Instruction>(Op)) {
- // Walk down the use-def chain.
- nameInstruction(I);
- Operands.push_back(I->getName());
- } else if (!isa<Function>(Op)) {
- // This must be an immediate value.
- std::string TextRepresentation;
- raw_string_ostream Stream(TextRepresentation);
- Op->printAsOperand(Stream, false);
- Operands.push_back(StringRef(Stream.str()));
- }
- }
-
- sortCommutativeOperands(I, Operands);
-
- // Initialize to a magic constant, so the state isn't zero.
- uint64_t Hash = MagicHashConstant;
-
- // Consider instruction opcode in the hash.
- Hash = hashing::detail::hash_16_bytes(Hash, I->getOpcode());
-
- // Operand opcodes for further sorting (commutative).
- SmallVector<int, 4> OperandsOpcodes;
-
- // Collect operand opcodes for hashing.
- for (auto &Op : I->operands())
- if (auto *I = dyn_cast<Instruction>(Op))
- OperandsOpcodes.push_back(I->getOpcode());
-
- sortCommutativeOperands(I, OperandsOpcodes);
-
- // Consider operand opcodes in the hash.
- for (const int Code : OperandsOpcodes)
- Hash = hashing::detail::hash_16_bytes(Hash, Code);
-
- // Base instruction name.
- SmallString<512> Name;
- Name.append("op" + std::to_string(Hash).substr(0, 5));
-
- // In case of CallInst, consider callee in the instruction name.
- if (const auto *CI = dyn_cast<CallInst>(I))
- if (const Function *F = CI->getCalledFunction())
- Name.append(F->getName());
-
- Name.append("(");
- for (size_t i = 0; i < Operands.size(); ++i) {
- Name.append(Operands[i]);
-
- if (i < Operands.size() - 1)
- Name.append(", ");
- }
- Name.append(")");
-
- if ((I->getName().empty() || RenameAll) && !I->getType()->isVoidTy())
- I->setName(Name);
-}
-
-/// Shortens instruction's name. This method removes called function name from
-/// the instruction name and substitutes the call chain with a corresponding
-/// list of operands.
-///
-/// Examples:
-/// op00000Callee(op00001Callee(...), vl00000Callee(1, 2), ...) ->
-/// op00000(op00001, vl00000, ...) vl00000Callee(1, 2) -> vl00000(1, 2)
-///
-/// This method omits output instructions and pre-output (instructions directly
-/// used by an output instruction) instructions (by default). By default it also
-/// does not affect user named instructions.
-///
-/// \param I Instruction whose name will be folded.
-void IRNormalizer::foldInstructionName(Instruction *I) const {
- // If this flag is raised, fold all regular
- // instructions (including pre-outputs).
- if (!FoldPreOutputs) {
- // Don't fold if one of the users is an output instruction.
- for (auto *U : I->users())
- if (auto *IU = dyn_cast<Instruction>(U))
- if (isOutput(IU))
- return;
- }
-
- // Don't fold if it is an output instruction or has no op prefix.
- if (isOutput(I) || I->getName().substr(0, 2) != "op")
- return;
-
- // Instruction operands.
- SmallVector<SmallString<64>, 4> Operands;
-
- for (auto &Op : I->operands()) {
- if (const auto *I = dyn_cast<Instruction>(Op)) {
- bool HasNormalName = I->getName().substr(0, 2) == "op" ||
- I->getName().substr(0, 2) == "vl";
-
- Operands.push_back(HasNormalName ? I->getName().substr(0, 7)
- : I->getName());
- }
- }
-
- sortCommutativeOperands(I, Operands);
-
- SmallString<256> Name;
- Name.append(I->getName().substr(0, 7));
-
- Name.append("(");
- for (size_t i = 0; i < Operands.size(); ++i) {
- Name.append(Operands[i]);
-
- if (i < Operands.size() - 1)
- Name.append(", ");
- }
- Name.append(")");
-
- I->setName(Name);
-}
-
-/// Reorders instructions by walking up the tree from each operand of an output
-/// instruction and reducing the def-use distance.
-/// This method assumes that output instructions were collected top-down,
-/// otherwise the def-use chain may be broken.
-/// This method is a wrapper for recursive reorderInstruction().
-///
-/// \see reorderInstruction()
-void IRNormalizer::reorderInstructions(Function &F) const {
- for (auto &BB : F) {
- LLVM_DEBUG(dbgs() << "Reordering instructions in basic block: "
- << BB.getName() << "\n");
- // Find the source nodes of the DAG of instructions in this basic block.
- // Source nodes are instructions that have side effects, are terminators, or
- // don't have a parent in the DAG of instructions.
- //
- // We must iterate from the first to the last instruction otherwise side
- // effecting instructions could be reordered.
-
- std::stack<Instruction *> TopologicalSort;
- SmallPtrSet<const Instruction *, 32> Visited;
- for (auto &I : BB) {
- // First process side effecting and terminating instructions.
- if (!(isOutput(&I) || I.isTerminator()))
- continue;
- LLVM_DEBUG(dbgs() << "\tReordering from source effecting instruction: ";
- I.dump());
- reorderDefinition(&I, TopologicalSort, Visited);
- }
-
- for (auto &I : BB) {
- // Process the remaining instructions.
- //
- // TODO: Do more a intelligent sorting of these instructions. For example,
- // seperate between dead instructinos and instructions used in another
- // block. Use properties of the CFG the order instructions that are used
- // in another block.
- if (Visited.contains(&I))
- continue;
- LLVM_DEBUG(dbgs() << "\tReordering from source instruction: "; I.dump());
- reorderDefinition(&I, TopologicalSort, Visited);
- }
-
- LLVM_DEBUG(dbgs() << "Inserting instructions into: " << BB.getName()
- << "\n");
- // Reorder based on the topological sort.
- while (!TopologicalSort.empty()) {
- auto *Instruction = TopologicalSort.top();
- auto FirstNonPHIOrDbgOrAlloca = BB.getFirstNonPHIOrDbgOrAlloca();
- if (auto *Call = dyn_cast<CallInst>(&*FirstNonPHIOrDbgOrAlloca)) {
- if (Call->getIntrinsicID() ==
- Intrinsic::experimental_convergence_entry ||
- Call->getIntrinsicID() == Intrinsic::experimental_convergence_loop)
- FirstNonPHIOrDbgOrAlloca++;
- }
- Instruction->moveBefore(&*FirstNonPHIOrDbgOrAlloca);
- TopologicalSort.pop();
- }
- }
-}
-
-void IRNormalizer::reorderDefinition(
- Instruction *Definition, std::stack<Instruction *> &TopologicalSort,
- SmallPtrSet<const Instruction *, 32> &Visited) const {
- if (Visited.contains(Definition))
- return;
- Visited.insert(Definition);
-
- {
- const auto *BasicBlock = Definition->getParent();
- const auto FirstNonPHIOrDbgOrAlloca =
- BasicBlock->getFirstNonPHIOrDbgOrAlloca();
- if (FirstNonPHIOrDbgOrAlloca == BasicBlock->end())
- return; // TODO: Is this necessary?
- if (Definition->comesBefore(&*FirstNonPHIOrDbgOrAlloca))
- return; // TODO: Do some kind of ordering for these instructions.
- }
-
- for (auto &Operand : Definition->operands()) {
- if (auto *Op = dyn_cast<Instruction>(Operand)) {
- if (Op->getParent() != Definition->getParent())
- continue; // Only reorder instruction within the same basic block
- reorderDefinition(Op, TopologicalSort, Visited);
- }
- }
-
- LLVM_DEBUG(dbgs() << "\t\tNext in topological sort: "; Definition->dump());
- if (Definition->isTerminator())
- return;
- if (auto *Call = dyn_cast<CallInst>(Definition)) {
- if (Call->isMustTailCall())
- return;
- if (Call->getIntrinsicID() == Intrinsic::experimental_deoptimize)
- return;
- if (Call->getIntrinsicID() == Intrinsic::experimental_convergence_entry)
- return;
- if (Call->getIntrinsicID() == Intrinsic::experimental_convergence_loop)
- return;
- }
- if (auto *BitCast = dyn_cast<BitCastInst>(Definition)) {
- if (auto *Call = dyn_cast<CallInst>(BitCast->getOperand(0))) {
- if (Call->isMustTailCall())
- return;
- }
- }
-
- TopologicalSort.emplace(Definition);
-}
-
-/// Reorders instruction's operands alphabetically. This method assumes
-/// that passed instruction is commutative. Changing the operand order
-/// in other instructions may change the semantics.
-///
-/// \param I Instruction whose operands will be reordered.
-void IRNormalizer::reorderInstructionOperandsByNames(Instruction *I) const {
- // This method assumes that passed I is commutative,
- // changing the order of operands in other instructions
- // may change the semantics.
-
- // Instruction operands for further sorting.
- SmallVector<std::pair<std::string, Value *>, 4> Operands;
-
- // Collect operands.
- for (auto &Op : I->operands()) {
- if (auto *V = dyn_cast<Value>(Op)) {
- if (isa<Instruction>(V)) {
- // This is an an instruction.
- Operands.push_back(std::pair<std::string, Value *>(V->getName(), V));
- } else {
- std::string TextRepresentation;
- raw_string_ostream Stream(TextRepresentation);
- Op->printAsOperand(Stream, false);
- Operands.push_back(std::pair<std::string, Value *>(Stream.str(), V));
- }
- }
- }
-
- // Sort operands.
- sortCommutativeOperands(I, Operands);
-
- // Reorder operands.
- unsigned Position = 0;
- for (auto &Op : I->operands()) {
- Op.set(Operands[Position].second);
- Position += 1;
- }
-}
-
-/// Reorders PHI node's values according to the names of corresponding basic
-/// blocks.
-///
-/// \param Phi PHI node to normalize.
-void IRNormalizer::reorderPHIIncomingValues(PHINode *Phi) const {
- // Values for further sorting.
- SmallVector<std::pair<Value *, BasicBlock *>, 2> Values;
-
- // Collect blocks and corresponding values.
- for (auto &BB : Phi->blocks()) {
- Value *V = Phi->getIncomingValueForBlock(BB);
- Values.push_back(std::pair<Value *, BasicBlock *>(V, BB));
- }
-
- // Sort values according to the name of a basic block.
- llvm::sort(Values, [](const std::pair<Value *, BasicBlock *> &LHS,
- const std::pair<Value *, BasicBlock *> &RHS) {
- return LHS.second->getName() < RHS.second->getName();
- });
-
- // Swap.
- for (unsigned i = 0; i < Values.size(); ++i) {
- Phi->setIncomingBlock(i, Values[i].second);
- Phi->setIncomingValue(i, Values[i].first);
- }
-}
-
-/// Returns a vector of output instructions. An output is an instruction which
-/// has side-effects or is ReturnInst. Uses isOutput().
-///
-/// \see isOutput()
-/// \param F Function to collect outputs from.
-SmallVector<Instruction *, 16>
-IRNormalizer::collectOutputInstructions(Function &F) const {
- // Output instructions are collected top-down in each function,
- // any change may break the def-use chain in reordering methods.
- SmallVector<Instruction *, 16> Outputs;
- for (auto &I : instructions(F))
- if (isOutput(&I))
- Outputs.push_back(&I);
- return Outputs;
-}
-
-/// Helper method checking whether the instruction may have side effects or is
-/// ReturnInst.
-///
-/// \param I Considered instruction.
-bool IRNormalizer::isOutput(const Instruction *I) const {
- // Outputs are such instructions which may have side effects or is ReturnInst.
- return I->mayHaveSideEffects() || isa<ReturnInst>(I);
-}
-
-/// Helper method checking whether the instruction has users and only
-/// immediate operands.
-///
-/// \param I Considered instruction.
-bool IRNormalizer::isInitialInstruction(const Instruction *I) const {
- // Initial instructions are such instructions whose values are used by
- // other instructions, yet they only depend on immediate values.
- return !I->user_empty() && hasOnlyImmediateOperands(I);
-}
-
-/// Helper method checking whether the instruction has only immediate operands.
-///
-/// \param I Considered instruction.
-bool IRNormalizer::hasOnlyImmediateOperands(const Instruction *I) const {
- for (const auto &Op : I->operands())
- if (isa<Instruction>(Op))
- return false; // Found non-immediate operand (instruction).
- return true;
-}
-
-/// Helper method returning indices (distance from the beginning of the basic
-/// block) of outputs using the \p I (eliminates repetitions). Walks down the
-/// def-use tree recursively.
-///
-/// \param I Considered instruction.
-/// \param Visited Set of visited instructions.
-SetVector<int> IRNormalizer::getOutputFootprint(
- Instruction *I, SmallPtrSet<const Instruction *, 32> &Visited) const {
-
- // Vector containing indexes of outputs (no repetitions),
- // which use I in the order of walking down the def-use tree.
- SetVector<int> Outputs;
-
- if (!Visited.count(I)) {
- Visited.insert(I);
-
- if (isOutput(I)) {
- // Gets output instruction's parent function.
- Function *Func = I->getParent()->getParent();
-
- // Finds and inserts the index of the output to the vector.
- unsigned Count = 0;
- for (const auto &B : *Func) {
- for (const auto &E : B) {
- if (&E == I)
- Outputs.insert(Count);
- Count += 1;
- }
- }
-
- // Returns to the used instruction.
- return Outputs;
- }
-
- for (auto *U : I->users()) {
- if (auto *UI = dyn_cast<Instruction>(U)) {
- // Vector for outputs which use UI.
- SetVector<int> OutputsUsingUI = getOutputFootprint(UI, Visited);
- // Insert the indexes of outputs using UI.
- Outputs.insert(OutputsUsingUI.begin(), OutputsUsingUI.end());
- }
- }
- }
-
- // Return to the used instruction.
- return Outputs;
-}
-
-PreservedAnalyses IRNormalizerPass::run(Function &F,
- FunctionAnalysisManager &AM) const {
- IRNormalizer{}.runOnFunction(F);
- return PreservedAnalyses::all();
-}
diff --git a/llvm/test/Transforms/IRNormalizer/naming-args-instr-blocks.ll b/llvm/test/Transforms/IRNormalizer/naming-args-instr-blocks.ll
deleted file mode 100644
index 7845a22e3ae174..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/naming-args-instr-blocks.ll
+++ /dev/null
@@ -1,18 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-define i32 @foo(i32) {
-; CHECK-LABEL: define i32 @foo(
-; CHECK-SAME: i32 [[A0:%.*]]) {
-; CHECK-NEXT: [[BB17254:.*:]]
-; CHECK-NEXT: %"vl24903([[A0]], 2)" = add i32 [[A0]], 2
-; CHECK-NEXT: %"op10412(vl24903)" = add i32 6, %"vl24903([[A0]], 2)"
-; CHECK-NEXT: ret i32 %"op10412(vl24903)"
-;
-entry:
- %a = add i32 %0, 2
-
- %b = add i32 %a, 6
-
- ret i32 %b
-}
diff --git a/llvm/test/Transforms/IRNormalizer/naming-arguments.ll b/llvm/test/Transforms/IRNormalizer/naming-arguments.ll
deleted file mode 100644
index a0066c97ca3db3..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/naming-arguments.ll
+++ /dev/null
@@ -1,13 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-define i32 @foo(i32, i32) {
-; CHECK-LABEL: define i32 @foo(
-; CHECK-SAME: i32 [[A0:%.*]], i32 [[A1:%.*]]) {
-; CHECK-NEXT: [[BB17254:.*:]]
-; CHECK-NEXT: %"vl20416([[A0]], [[A1]])" = mul i32 [[A0]], [[A1]]
-; CHECK-NEXT: ret i32 %"vl20416([[A0]], [[A1]])"
-;
- %tmp = mul i32 %0, %1
- ret i32 %tmp
-}
diff --git a/llvm/test/Transforms/IRNormalizer/naming.ll b/llvm/test/Transforms/IRNormalizer/naming.ll
deleted file mode 100644
index 7c93a6213a4a9f..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/naming.ll
+++ /dev/null
@@ -1,30 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-define i32 @foo(i32 %a0) {
-; CHECK-LABEL: define i32 @foo(
-; CHECK-SAME: i32 [[A0:%.*]]) {
-; CHECK-NEXT: [[BB17254:.*:]]
-; CHECK-NEXT: %"vl12603([[A0]], 2)" = add i32 [[A0]], 2
-; CHECK-NEXT: ret i32 %"vl12603([[A0]], 2)"
-;
-entry:
- %a = add i32 %a0, 2
- ret i32 %a
-}
-
-define i32 @bar(i32 %a0) {
-; CHECK-LABEL: define i32 @bar(
-; CHECK-SAME: i32 [[A0:%.*]]) {
-; CHECK-NEXT: [[BB17254:.*:]]
-; CHECK-NEXT: %"vl76167([[A0]], 2)" = add i32 [[A0]], 2
-; CHECK-NEXT: %"op10412(vl76167)" = add i32 6, %"vl76167([[A0]], 2)"
-; CHECK-NEXT: %"op10412(op10412)" = add i32 8, %"op10412(vl76167)"
-; CHECK-NEXT: ret i32 %"op10412(op10412)"
-;
-entry:
- %a = add i32 %a0, 2
- %b = add i32 %a, 6
- %c = add i32 %b, 8
- ret i32 %c
-}
diff --git a/llvm/test/Transforms/IRNormalizer/regression-convergence-tokens.ll b/llvm/test/Transforms/IRNormalizer/regression-convergence-tokens.ll
deleted file mode 100644
index 633cf091da5085..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/regression-convergence-tokens.ll
+++ /dev/null
@@ -1,27 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-; Function Attrs: convergent nounwind readnone
-define i32 @nested(i32 %src) #0 {
-; CHECK-LABEL: define i32 @nested(
-; CHECK-SAME: i32 [[A0:%.*]]) #[[ATTR0:[0-9]+]] {
-; CHECK-NEXT: [[BB15160:.*:]]
-; CHECK-NEXT: [[T1:%.*]] = call token @llvm.experimental.convergence.entry()
-; CHECK-NEXT: %"vl15001llvm.experimental.convergence.anchor()" = call token @llvm.experimental.convergence.anchor()
-; CHECK-NEXT: %"op68297llvm.amdgcn.readfirstlane.i32([[A0]], vl15001llvm.experimental.convergence.anchor())" = call i32 @llvm.amdgcn.readfirstlane.i32(i32 [[A0]]) [ "convergencectrl"(token %"vl15001llvm.experimental.convergence.anchor()") ]
-; CHECK-NEXT: ret i32 undef
-;
- %t1 = call token @llvm.experimental.convergence.entry()
- %t2 = call token @llvm.experimental.convergence.anchor()
- %r2 = call i32 @llvm.amdgcn.readfirstlane(i32 %src) [ "convergencectrl"(token %t2) ]
- ret i32 undef
-}
-
-; Function Attrs: convergent nounwind readnone
-declare i32 @llvm.amdgcn.readfirstlane(i32) #0
-
-declare token @llvm.experimental.convergence.entry()
-
-declare token @llvm.experimental.convergence.anchor()
-
-attributes #0 = { convergent nounwind readnone }
diff --git a/llvm/test/Transforms/IRNormalizer/regression-coro-elide-musttail.ll b/llvm/test/Transforms/IRNormalizer/regression-coro-elide-musttail.ll
deleted file mode 100644
index 891eae0954a7c1..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/regression-coro-elide-musttail.ll
+++ /dev/null
@@ -1,21 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-define fastcc void @foo.resume_musttail(ptr %FramePtr) {
-; CHECK-LABEL: define fastcc void @foo.resume_musttail(
-; CHECK-SAME: ptr [[A0:%.*]]) {
-; CHECK-NEXT: [[BB15160:.*:]]
-; CHECK-NEXT: [[TMP0:%.*]] = tail call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
-; CHECK-NEXT: musttail call fastcc void undef(ptr null)
-; CHECK-NEXT: ret void
-;
-entry:
- %0 = tail call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
- musttail call fastcc void undef(ptr null)
- ret void
-}
-
-; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read)
-declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr) #0
-
-attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
diff --git a/llvm/test/Transforms/IRNormalizer/regression-deoptimize.ll b/llvm/test/Transforms/IRNormalizer/regression-deoptimize.ll
deleted file mode 100644
index 594ea6109499a1..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/regression-deoptimize.ll
+++ /dev/null
@@ -1,18 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
-
-define void @test1() {
-; CHECK-LABEL: define void @test1() {
-; CHECK-NEXT: [[BB15160:.*:]]
-; CHECK-NEXT: [[TMP0:%.*]] = load i8, ptr null, align 1
-; CHECK-NEXT: call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
-; CHECK-NEXT: ret void
-;
- %1 = load i8, ptr null, align 1
- call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
- ret void
-}
-
-declare void @llvm.experimental.deoptimize.isVoid(...)
diff --git a/llvm/test/Transforms/IRNormalizer/regression-dont-hoist-deoptimize.ll b/llvm/test/Transforms/IRNormalizer/regression-dont-hoist-deoptimize.ll
deleted file mode 100644
index d3d3e33723f029..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/regression-dont-hoist-deoptimize.ll
+++ /dev/null
@@ -1,20 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
-target triple = "x86_64-unknown-linux-gnu"
-
-declare void @llvm.experimental.deoptimize.isVoid(...)
-
-define void @widget() {
-; CHECK-LABEL: define void @widget() {
-; CHECK-NEXT: [[BB15160:.*:]]
-; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 0 to i32
-; CHECK-NEXT: call void (...) @llvm.experimental.deoptimize.isVoid(i32 0) [ "deopt"() ]
-; CHECK-NEXT: ret void
-;
-bb:
- %tmp3 = trunc i64 0 to i32
- call void (...) @llvm.experimental.deoptimize.isVoid(i32 0) [ "deopt"() ]
- ret void
-}
diff --git a/llvm/test/Transforms/IRNormalizer/regression-infinite-loop.ll b/llvm/test/Transforms/IRNormalizer/regression-infinite-loop.ll
deleted file mode 100644
index 35ac0fd8c329a7..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/regression-infinite-loop.ll
+++ /dev/null
@@ -1,195 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-define void @test(ptr, i32) {
-; CHECK-LABEL: define void @test(
-; CHECK-SAME: ptr [[A0:%.*]], i32 [[A1:%.*]]) {
-; CHECK-NEXT: [[BB76951:.*]]:
-; CHECK-NEXT: %"vl72693([[A1]], 1)" = add i32 [[A1]], 1
-; CHECK-NEXT: br label %[[BB16110:.*]]
-; CHECK: [[BB16110]]:
-; CHECK-NEXT: %"op10912(op18080, vl72693)" = phi i32 [ %"op18080(op10412, op17645)", %[[BB16110]] ], [ %"vl72693([[A1]], 1)", %[[BB76951]] ]
-; CHECK-NEXT: %"op10912(op17645, vl72693)" = phi i32 [ %"op17645(op10912)70", %[[BB16110]] ], [ %"vl72693([[A1]], 1)", %[[BB76951]] ]
-; CHECK-NEXT: %"op15084(op10912)" = mul i32 %"op10912(op18080, vl72693)", undef
-; CHECK-NEXT: %"op16562(op15084)" = xor i32 -1, %"op15084(op10912)"
-; CHECK-NEXT: %"op44627(op10912, op16562)" = add i32 %"op10912(op18080, vl72693)", %"op16562(op15084)"
-; CHECK-NEXT: %"op17645(op10912)" = add i32 -1, %"op10912(op17645, vl72693)"
-; CHECK-NEXT: %"op18080(op17645, op44627)" = add i32 %"op17645(op10912)", %"op44627(op10912, op16562)"
-; CHECK-NEXT: %"op17720(op15084, op18080)" = mul i32 %"op15084(op10912)", %"op18080(op17645, op44627)"
-; CHECK-NEXT: %"op16562(op17720)" = xor i32 -1, %"op17720(op15084, op18080)"
-; CHECK-NEXT: %"op17430(op16562, op18080)" = add i32 %"op16562(op17720)", %"op18080(op17645, op44627)"
-; CHECK-NEXT: %"op10412(op17430)" = add i32 %"op17430(op16562, op18080)", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)" = mul i32 %"op10412(op17430)", %"op17720(op15084, op18080)"
-; CHECK-NEXT: %"op16562(op17720)1" = xor i32 -1, %"op17720(op10412, op17720)"
-; CHECK-NEXT: %"op17430(op10412, op16562)" = add i32 %"op10412(op17430)", %"op16562(op17720)1"
-; CHECK-NEXT: %"op10412(op17430)2" = add i32 %"op17430(op10412, op16562)", undef
-; CHECK-NEXT: %"op10412(op10412)" = add i32 %"op10412(op17430)2", undef
-; CHECK-NEXT: %"op10412(op10412)3" = add i32 %"op10412(op10412)", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)4" = mul i32 %"op10412(op17430)2", %"op17720(op10412, op17720)"
-; CHECK-NEXT: %"op17720(op10412, op17720)5" = mul i32 %"op10412(op10412)3", %"op17720(op10412, op17720)4"
-; CHECK-NEXT: %"op16562(op17720)6" = xor i32 -1, %"op17720(op10412, op17720)5"
-; CHECK-NEXT: %"op17430(op10412, op16562)7" = add i32 %"op10412(op10412)3", %"op16562(op17720)6"
-; CHECK-NEXT: %"op10412(op17430)8" = add i32 %"op17430(op10412, op16562)7", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)9" = mul i32 %"op10412(op17430)8", %"op17720(op10412, op17720)5"
-; CHECK-NEXT: %"op16562(op17720)10" = xor i32 -1, %"op17720(op10412, op17720)9"
-; CHECK-NEXT: %"op17430(op10412, op16562)11" = add i32 %"op10412(op17430)8", %"op16562(op17720)10"
-; CHECK-NEXT: %"op10412(op17430)12" = add i32 %"op17430(op10412, op16562)11", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)13" = mul i32 %"op10412(op17430)12", %"op17720(op10412, op17720)9"
-; CHECK-NEXT: %"op16562(op17720)14" = xor i32 -1, %"op17720(op10412, op17720)13"
-; CHECK-NEXT: %"op17430(op10412, op16562)15" = add i32 %"op10412(op17430)12", %"op16562(op17720)14"
-; CHECK-NEXT: %"op10412(op17430)16" = add i32 %"op17430(op10412, op16562)15", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)17" = mul i32 %"op10412(op17430)16", %"op17720(op10412, op17720)13"
-; CHECK-NEXT: %"op16562(op17720)18" = xor i32 -1, %"op17720(op10412, op17720)17"
-; CHECK-NEXT: %"op17430(op10412, op16562)19" = add i32 %"op10412(op17430)16", %"op16562(op17720)18"
-; CHECK-NEXT: %"op10412(op17430)20" = add i32 %"op17430(op10412, op16562)19", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)21" = mul i32 %"op10412(op17430)20", %"op17720(op10412, op17720)17"
-; CHECK-NEXT: %"op16562(op17720)22" = xor i32 -1, %"op17720(op10412, op17720)21"
-; CHECK-NEXT: %"op17430(op10412, op16562)23" = add i32 %"op10412(op17430)20", %"op16562(op17720)22"
-; CHECK-NEXT: %"op17645(op10912)24" = add i32 -9, %"op10912(op17645, vl72693)"
-; CHECK-NEXT: %"op18080(op17430, op17645)" = add i32 %"op17430(op10412, op16562)23", %"op17645(op10912)24"
-; CHECK-NEXT: %"op17720(op17720, op18080)" = mul i32 %"op17720(op10412, op17720)21", %"op18080(op17430, op17645)"
-; CHECK-NEXT: %"op16562(op17720)25" = xor i32 -1, %"op17720(op17720, op18080)"
-; CHECK-NEXT: %"op17430(op16562, op18080)26" = add i32 %"op16562(op17720)25", %"op18080(op17430, op17645)"
-; CHECK-NEXT: %"op10412(op17430)27" = add i32 %"op17430(op16562, op18080)26", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)28" = mul i32 %"op10412(op17430)27", %"op17720(op17720, op18080)"
-; CHECK-NEXT: %"op16562(op17720)29" = xor i32 -1, %"op17720(op10412, op17720)28"
-; CHECK-NEXT: %"op17430(op10412, op16562)30" = add i32 %"op10412(op17430)27", %"op16562(op17720)29"
-; CHECK-NEXT: %"op10412(op17430)31" = add i32 %"op17430(op10412, op16562)30", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)32" = mul i32 %"op10412(op17430)31", %"op17720(op10412, op17720)28"
-; CHECK-NEXT: %"op16562(op17720)33" = xor i32 -1, %"op17720(op10412, op17720)32"
-; CHECK-NEXT: %"op17430(op10412, op16562)34" = add i32 %"op10412(op17430)31", %"op16562(op17720)33"
-; CHECK-NEXT: %"op10412(op17430)35" = add i32 %"op17430(op10412, op16562)34", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)36" = mul i32 %"op10412(op17430)35", %"op17720(op10412, op17720)32"
-; CHECK-NEXT: %"op16562(op17720)37" = xor i32 -1, %"op17720(op10412, op17720)36"
-; CHECK-NEXT: %"op17430(op10412, op16562)38" = add i32 %"op10412(op17430)35", %"op16562(op17720)37"
-; CHECK-NEXT: %"op10412(op17430)39" = add i32 %"op17430(op10412, op16562)38", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)40" = mul i32 %"op10412(op17430)39", %"op17720(op10412, op17720)36"
-; CHECK-NEXT: %"op16562(op17720)41" = xor i32 -1, %"op17720(op10412, op17720)40"
-; CHECK-NEXT: %"op17430(op10412, op16562)42" = add i32 %"op10412(op17430)39", %"op16562(op17720)41"
-; CHECK-NEXT: %"op17645(op10912)43" = add i32 -14, %"op10912(op17645, vl72693)"
-; CHECK-NEXT: %"op18080(op17430, op17645)44" = add i32 %"op17430(op10412, op16562)42", %"op17645(op10912)43"
-; CHECK-NEXT: %"op17720(op17720, op18080)45" = mul i32 %"op17720(op10412, op17720)40", %"op18080(op17430, op17645)44"
-; CHECK-NEXT: %"op16562(op17720)46" = xor i32 -1, %"op17720(op17720, op18080)45"
-; CHECK-NEXT: %"op17430(op16562, op18080)47" = add i32 %"op16562(op17720)46", %"op18080(op17430, op17645)44"
-; CHECK-NEXT: %"op10412(op17430)48" = add i32 %"op17430(op16562, op18080)47", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)49" = mul i32 %"op10412(op17430)48", %"op17720(op17720, op18080)45"
-; CHECK-NEXT: %"op16562(op17720)50" = xor i32 -1, %"op17720(op10412, op17720)49"
-; CHECK-NEXT: %"op17430(op10412, op16562)51" = add i32 %"op10412(op17430)48", %"op16562(op17720)50"
-; CHECK-NEXT: %"op10412(op17430)52" = add i32 %"op17430(op10412, op16562)51", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)53" = mul i32 %"op10412(op17430)52", %"op17720(op10412, op17720)49"
-; CHECK-NEXT: %"op16562(op17720)54" = xor i32 -1, %"op17720(op10412, op17720)53"
-; CHECK-NEXT: %"op17430(op10412, op16562)55" = add i32 %"op10412(op17430)52", %"op16562(op17720)54"
-; CHECK-NEXT: %"op10412(op17430)56" = add i32 %"op17430(op10412, op16562)55", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)57" = mul i32 %"op10412(op17430)56", %"op17720(op10412, op17720)53"
-; CHECK-NEXT: %"op16562(op17720)58" = xor i32 -1, %"op17720(op10412, op17720)57"
-; CHECK-NEXT: %"op17430(op10412, op16562)59" = add i32 %"op10412(op17430)56", %"op16562(op17720)58"
-; CHECK-NEXT: %"op10412(op17430)60" = add i32 %"op17430(op10412, op16562)59", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)61" = mul i32 %"op10412(op17430)60", %"op17720(op10412, op17720)57"
-; CHECK-NEXT: %"op16562(op17720)62" = xor i32 -1, %"op17720(op10412, op17720)61"
-; CHECK-NEXT: %"op17430(op10412, op16562)63" = add i32 %"op10412(op17430)60", %"op16562(op17720)62"
-; CHECK-NEXT: %"op10412(op17430)64" = add i32 %"op17430(op10412, op16562)63", undef
-; CHECK-NEXT: %"op17720(op10412, op17720)65" = mul i32 %"op10412(op17430)64", %"op17720(op10412, op17720)61"
-; CHECK-NEXT: %"op16562(op17720)66" = xor i32 -1, %"op17720(op10412, op17720)65"
-; CHECK-NEXT: %"op17430(op10412, op16562)67" = add i32 %"op10412(op17430)64", %"op16562(op17720)66"
-; CHECK-NEXT: %"op10412(op17430)68" = add i32 %"op17430(op10412, op16562)67", undef
-; CHECK-NEXT: %"op10412(op10412)69" = add i32 %"op10412(op17430)68", undef
-; CHECK-NEXT: %"op17645(op10912)70" = add i32 -21, %"op10912(op17645, vl72693)"
-; CHECK-NEXT: %"op18080(op10412, op17645)" = add i32 %"op10412(op10412)69", %"op17645(op10912)70"
-; CHECK-NEXT: store i32 %"op18080(op10412, op17645)", ptr [[A0]], align 4
-; CHECK-NEXT: br label %[[BB16110]]
-;
-bb:
- %a = add i32 %1, 1
- br label %bb1
-
-bb1: ; preds = %bb1, %bb
- %tmp = phi i32 [ %a, %bb ], [ %tmp87, %bb1 ]
- %tmp2 = phi i32 [ %a, %bb ], [ %tmp86, %bb1 ]
- %tmp3 = mul i32 %tmp, undef
- %tmp4 = xor i32 %tmp3, -1
- %tmp5 = add i32 %tmp, %tmp4
- %tmp6 = add i32 %tmp2, -1
- %tmp7 = add i32 %tmp5, %tmp6
- %tmp8 = mul i32 %tmp7, %tmp3
- %tmp9 = xor i32 %tmp8, -1
- %tmp10 = add i32 %tmp7, %tmp9
- %tmp11 = add i32 %tmp10, undef
- %tmp12 = mul i32 %tmp11, %tmp8
- %tmp13 = xor i32 %tmp12, -1
- %tmp14 = add i32 %tmp11, %tmp13
- %tmp15 = add i32 %tmp14, undef
- %tmp16 = mul i32 %tmp15, %tmp12
- %tmp17 = add i32 %tmp15, undef
- %tmp18 = add i32 %tmp17, undef
- %tmp19 = mul i32 %tmp18, %tmp16
- %tmp20 = xor i32 %tmp19, -1
- %tmp21 = add i32 %tmp18, %tmp20
- %tmp22 = add i32 %tmp21, undef
- %tmp23 = mul i32 %tmp22, %tmp19
- %tmp24 = xor i32 %tmp23, -1
- %tmp25 = add i32 %tmp22, %tmp24
- %tmp26 = add i32 %tmp25, undef
- %tmp27 = mul i32 %tmp26, %tmp23
- %tmp28 = xor i32 %tmp27, -1
- %tmp29 = add i32 %tmp26, %tmp28
- %tmp30 = add i32 %tmp29, undef
- %tmp31 = mul i32 %tmp30, %tmp27
- %tmp32 = xor i32 %tmp31, -1
- %tmp33 = add i32 %tmp30, %tmp32
- %tmp34 = add i32 %tmp33, undef
- %tmp35 = mul i32 %tmp34, %tmp31
- %tmp36 = xor i32 %tmp35, -1
- %tmp37 = add i32 %tmp34, %tmp36
- %tmp38 = add i32 %tmp2, -9
- %tmp39 = add i32 %tmp37, %tmp38
- %tmp40 = mul i32 %tmp39, %tmp35
- %tmp41 = xor i32 %tmp40, -1
- %tmp42 = add i32 %tmp39, %tmp41
- %tmp43 = add i32 %tmp42, undef
- %tmp44 = mul i32 %tmp43, %tmp40
- %tmp45 = xor i32 %tmp44, -1
- %tmp46 = add i32 %tmp43, %tmp45
- %tmp47 = add i32 %tmp46, undef
- %tmp48 = mul i32 %tmp47, %tmp44
- %tmp49 = xor i32 %tmp48, -1
- %tmp50 = add i32 %tmp47, %tmp49
- %tmp51 = add i32 %tmp50, undef
- %tmp52 = mul i32 %tmp51, %tmp48
- %tmp53 = xor i32 %tmp52, -1
- %tmp54 = add i32 %tmp51, %tmp53
- %tmp55 = add i32 %tmp54, undef
- %tmp56 = mul i32 %tmp55, %tmp52
- %tmp57 = xor i32 %tmp56, -1
- %tmp58 = add i32 %tmp55, %tmp57
- %tmp59 = add i32 %tmp2, -14
- %tmp60 = add i32 %tmp58, %tmp59
- %tmp61 = mul i32 %tmp60, %tmp56
- %tmp62 = xor i32 %tmp61, -1
- %tmp63 = add i32 %tmp60, %tmp62
- %tmp64 = add i32 %tmp63, undef
- %tmp65 = mul i32 %tmp64, %tmp61
- %tmp66 = xor i32 %tmp65, -1
- %tmp67 = add i32 %tmp64, %tmp66
- %tmp68 = add i32 %tmp67, undef
- %tmp69 = mul i32 %tmp68, %tmp65
- %tmp70 = xor i32 %tmp69, -1
- %tmp71 = add i32 %tmp68, %tmp70
- %tmp72 = add i32 %tmp71, undef
- %tmp73 = mul i32 %tmp72, %tmp69
- %tmp74 = xor i32 %tmp73, -1
- %tmp75 = add i32 %tmp72, %tmp74
- %tmp76 = add i32 %tmp75, undef
- %tmp77 = mul i32 %tmp76, %tmp73
- %tmp78 = xor i32 %tmp77, -1
- %tmp79 = add i32 %tmp76, %tmp78
- %tmp80 = add i32 %tmp79, undef
- %tmp81 = mul i32 %tmp80, %tmp77
- %tmp82 = xor i32 %tmp81, -1
- %tmp83 = add i32 %tmp80, %tmp82
- %tmp84 = add i32 %tmp83, undef
- %tmp85 = add i32 %tmp84, undef
- %tmp86 = add i32 %tmp2, -21
- %tmp87 = add i32 %tmp85, %tmp86
- store i32 %tmp87, ptr %0
- br label %bb1
-}
diff --git a/llvm/test/Transforms/IRNormalizer/reordering-basic.ll b/llvm/test/Transforms/IRNormalizer/reordering-basic.ll
deleted file mode 100644
index fd09ce016addbc..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/reordering-basic.ll
+++ /dev/null
@@ -1,58 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
-; RUN: opt -S -passes=normalize < %s | FileCheck %s
-
-define double @foo(double %a0, double %a1) {
-; CHECK-LABEL: define double @foo(
-; CHECK-SAME: double [[A0:%.*]], double [[A1:%.*]]) {
-; CHECK-NEXT: [[BB17254:.*:]]
-; CHECK-NEXT: %"vl93562([[A0]], 2.000000e+00)" = fmul double [[A0]], 2.000000e+00
-; CHECK-NEXT: %"op95858(vl93562)" = fmul double 6.000000e+00, %"vl93562([[A0]], 2.000000e+00)"
-; CHECK-NEXT: [[A:%.*]] = fmul double [[A0]], [[A1]]
-; CHECK-NEXT: [[C:%.*]] = fmul double 6.000000e+00, [[A]]
-; CHECK-NEXT: ret double %"op95858(vl93562)"
-;
-entry:
- %a = fmul double %a0, %a1
- %b = fmul double %a0, 2.000000e+00
- %c = fmul double %a, 6.000000e+00
- %d = fmul double %b, 6.000000e+00
- ret double %d
-}
-
-declare double @bir()
-
-declare double @bar()
-
-define double @baz(double %x) {
-; CHECK-LABEL: define double @baz(
-; CHECK-SAME: double [[A0:%.*]]) {
-; CHECK-NEXT: [[BB76951:.*:]]
-; CHECK-NEXT: [[IFCOND:%.*]] = fcmp one double [[A0]], 0.000000e+00
-; CHECK-NEXT: br i1 [[IFCOND]], label %[[BB91455:.*]], label %[[BB914551:.*]]
-; CHECK: [[BB91455]]:
-; CHECK-NEXT: %"vl15001bir()" = call double @bir()
-; CHECK-NEXT: br label %[[BB17254:.*]]
-; CHECK: [[BB914551]]:
-; CHECK-NEXT: %"vl69719bar()" = call double @bar()
-; CHECK-NEXT: br label %[[BB17254]]
-; CHECK: [[BB17254]]:
-; CHECK-NEXT: %"op19734(vl15001, vl69719)" = phi double [ %"vl15001bir()", %[[BB91455]] ], [ %"vl69719bar()", %[[BB914551]] ]
-; CHECK-NEXT: ret double %"op19734(vl15001, vl69719)"
-;
-entry:
- %ifcond = fcmp one double %x, 0.000000e+00
- br i1 %ifcond, label %then, label %else
-
-then: ; preds = %entry
- %calltmp = call double @bir()
- br label %ifcont
-
-else: ; preds = %entry
- %calltmp1 = call double @bar()
- br label %ifcont
-
-ifcont: ; preds = %else, %then
- %iftmp = phi double [ %calltmp, %then ], [ %calltmp1, %else ]
- ret double %iftmp
-}
-
diff --git a/llvm/test/Transforms/IRNormalizer/reordering.ll b/llvm/test/Transforms/IRNormalizer/reordering.ll
deleted file mode 100644
index 313d44a88e3cb7..00000000000000
--- a/llvm/test/Transforms/IRNormalizer/reordering.ll
+++ /dev/null
@@ -1,163 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 4
-; RUN: opt -S -passes=normalize -verify-each -norm-rename-all=false < %s | FileCheck %s
-
-define void @foo() {
-; CHECK-LABEL: define void @foo() {
-; CHECK-NEXT: bb17254:
-; CHECK-NEXT: ret void
-;
- ret void
-}
-
-define void @empty_basic_block() {
-; CHECK-LABEL: define void @empty_basic_block() {
-; CHECK-NEXT: exit:
-; CHECK-NEXT: ret void
-;
-exit:
- ret void
-}
-
-declare void @effecting()
-
-; Place dead instruction(s) before the terminator
-define void @call_effecting() {
-; CHECK-LABEL: define void @call_effecting() {
-; CHECK-NEXT: bb15160:
-; CHECK-NEXT: call void @effecting()
-; CHECK-NEXT: [[TMP0:%.*]] = add i32 0, 1
-; CHECK-NEXT: ret void
-;
- %1 = add i32 0, 1
- call void @effecting()
- ret void
-}
-
-define void @dont_move_above_phi() {
-; CHECK-LABEL: define void @dont_move_above_phi() {
-; CHECK-NEXT: bb76951:
-; CHECK-NEXT: br label [[EXIT:%.*]]
-; CHECK: exit:
-; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ 0, [[BB76951:%.*]] ]
-; CHECK-NEXT: call void @effecting()
-; CHECK-NEXT: ret void
-;
- br label %exit
-exit:
- %1 = phi i32 [0, %0]
- call void @effecting()
- ret void
-}
-
-define void @dont_move_above_alloca() {
-; CHECK-LABEL: define void @dont_move_above_alloca() {
-; CHECK-NEXT: bb15160:
-; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @effecting()
-; CHECK-NEXT: ret void
-;
- %1 = alloca i32
- call void @effecting()
- ret void
-}
-
-declare void @effecting1()
-
-define void @dont_reorder_effecting() {
-; CHECK-LABEL: define void @dont_reorder_effecting() {
-; CHECK-NEXT: bb10075:
-; CHECK-NEXT: call void @effecting()
-; CHECK-NEXT: call void @effecting1()
-; CHECK-NEXT: ret void
-;
- call void @effecting()
- call void @effecting1()
- ret void
-}
-
-declare void @effecting2(i32)
-
-define void @dont_reorder_effecting1() {
-; CHECK-LABEL: define void @dont_reorder_effecting1() {
-; CHECK-NEXT: bb10075:
-; CHECK-NEXT: [[ONE:%.*]] = add i32 1, 1
-; CHECK-NEXT: call void @effecting2(i32 [[ONE]])
-; CHECK-NEXT: [[TWO:%.*]] = add i32 2, 2
-; CHECK-NEXT: call void @effecting2(i32 [[TWO]])
-; CHECK-NEXT: ret void
-;
- %one = add i32 1, 1
- %two = add i32 2, 2
- call void @effecting2(i32 %one)
- call void @effecting2(i32 %two)
- ret void
-}
-
-define void @dont_reorder_across_blocks() {
-; CHECK-LABEL: define void @dont_reorder_across_blocks() {
-; CHECK-NEXT: bb76951:
-; CHECK-NEXT: [[ONE:%.*]] = add i32 1, 1
-; CHECK-NEXT: br label [[EXIT:%.*]]
-; CHECK: exit:
-; CHECK-NEXT: call void @effecting2(i32 [[ONE]])
-; CHECK-NEXT: ret void
-;
- %one = add i32 1, 1
- br label %exit
-exit:
- call void @effecting2(i32 %one)
- ret void
-}
-
-define void @independentldst(ptr %a, ptr %b) {
-; CHECK-LABEL: define void @independentldst(
-; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]]) {
-; CHECK-NEXT: bb10495:
-; CHECK-NEXT: %"vl12961([[B]])" = load i32, ptr [[B]], align 4
-; CHECK-NEXT: store i32 %"vl12961([[B]])", ptr [[A]], align 4
-; CHECK-NEXT: %"vl89528([[A]])" = load i32, ptr [[A]], align 4
-; CHECK-NEXT: store i32 %"vl89528([[A]])", ptr [[B]], align 4
-; CHECK-NEXT: ret void
-;
- %2 = load i32, ptr %a
- %3 = load i32, ptr %b
- store i32 %3, ptr %a
- store i32 %2, ptr %b
- ret void
-}
-
-define void @multiple_use_ld(ptr %a, ptr %b) {
-; CHECK-LABEL: define void @multiple_use_ld(
-; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]]) {
-; CHECK-NEXT: bb14927:
-; CHECK-NEXT: %"vl16793([[A]])" = load i32, ptr [[A]], align 4
-; CHECK-NEXT: store i32 %"vl16793([[A]])", ptr [[A]], align 4
-; CHECK-NEXT: %"vl89528([[B]])" = load i32, ptr [[B]], align 4
-; CHECK-NEXT: store i32 %"vl89528([[B]])", ptr [[B]], align 4
-; CHECK-NEXT: store i32 %"vl16793([[A]])", ptr [[A]], align 4
-; CHECK-NEXT: ret void
-;
- %2 = load i32, ptr %a
- store i32 %2, ptr %a
- %3 = load i32, ptr %b
- store i32 %3, ptr %b
- store i32 %2, ptr %a
- ret void
-}
-
-; This is an incorrect transformation. Moving the store above the load could
-; change the loaded value. To do this, the pointers would need to be `noalias`.
-define void @undef_st(ptr %a, ptr %b) {
-; CHECK-LABEL: define void @undef_st(
-; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]]) {
-; CHECK-NEXT: bb10495:
-; CHECK-NEXT: store i32 undef, ptr [[B]], align 4
-; CHECK-NEXT: %"vl16028([[A]])" = load i32, ptr [[A]], align 4
-; CHECK-NEXT: store i32 %"vl16028([[A]])", ptr [[A]], align 4
-; CHECK-NEXT: ret void
-;
- %2 = load i32, ptr %a
- store i32 undef, ptr %b
- store i32 %2, ptr %a
- ret void
-}
More information about the llvm-commits
mailing list