llvm/llvm/tools/bugpoint-passes/TestPasses.cpp

//===- TestPasses.cpp - "buggy" passes used to test bugpoint --------------===//
//
//
// 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 contains "buggy" passes that are used to test bugpoint, to check
// that it is narrowing down testcases correctly.
//
//===----------------------------------------------------------------------===//

#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/InstVisitor.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Type.h"
#include "llvm/Pass.h"

#include "llvm/IR/PatternMatch.h"
usingnamespacellvm::PatternMatch;
usingnamespacellvm;

namespace {
/// CrashOnCalls - This pass is used to test bugpoint.  It intentionally
/// crashes on any call instructions.
class CrashOnCalls : public FunctionPass { … };
}

char CrashOnCalls::ID = …;
static RegisterPass<CrashOnCalls>
  X("bugpoint-crashcalls",
    "BugPoint Test Pass - Intentionally crash on CallInsts");

namespace {
/// DeleteCalls - This pass is used to test bugpoint.  It intentionally
/// deletes some call instructions, "misoptimizing" the program.
class DeleteCalls : public FunctionPass { … };
}

char DeleteCalls::ID = …;
static RegisterPass<DeleteCalls>
  Y("bugpoint-deletecalls",
    "BugPoint Test Pass - Intentionally 'misoptimize' CallInsts");

namespace {
  /// CrashOnDeclFunc - This pass is used to test bugpoint.  It intentionally
/// crashes if the module has an undefined function (ie a function that is
/// defined in an external module).
class CrashOnDeclFunc : public ModulePass { … };
}

char CrashOnDeclFunc::ID = …;
static RegisterPass<CrashOnDeclFunc>
  Z("bugpoint-crash-decl-funcs",
    "BugPoint Test Pass - Intentionally crash on declared functions");

namespace {
/// CrashOnOneCU - This pass is used to test bugpoint. It intentionally
/// crashes if the Module has two or more compile units
class CrashOnTooManyCUs : public ModulePass { … };
}

char CrashOnTooManyCUs::ID = …;
static RegisterPass<CrashOnTooManyCUs>
    A("bugpoint-crash-too-many-cus",
      "BugPoint Test Pass - Intentionally crash on too many CUs");

namespace {
class CrashOnFunctionAttribute : public FunctionPass { … };
} // namespace

char CrashOnFunctionAttribute::ID = …;
static RegisterPass<CrashOnFunctionAttribute>
    B("bugpoint-crashfuncattr", "BugPoint Test Pass - Intentionally crash on "
                                "function attribute 'bugpoint-crash'");

namespace {
class CrashOnMetadata : public FunctionPass { … };
} // namespace

char CrashOnMetadata::ID = …;
static RegisterPass<CrashOnMetadata>
    C("bugpoint-crashmetadata",
      "BugPoint Test Pass - Intentionally crash on "
      "fabs calls with fpmath metadata and an fadd as argument");