diff options
Diffstat (limited to 'llvm/tools/llvm-reduce')
| -rw-r--r-- | llvm/tools/llvm-reduce/CMakeLists.txt | 24 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/DeltaManager.h | 25 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/LLVMBuild.txt | 24 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/TestRunner.cpp | 60 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/TestRunner.h | 56 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/deltas/Delta.cpp | 203 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/deltas/Delta.h | 89 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp | 80 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/deltas/ReduceFunctions.h | 20 | ||||
| -rw-r--r-- | llvm/tools/llvm-reduce/llvm-reduce.cpp | 105 |
10 files changed, 0 insertions, 686 deletions
diff --git a/llvm/tools/llvm-reduce/CMakeLists.txt b/llvm/tools/llvm-reduce/CMakeLists.txt deleted file mode 100644 index 1de3a9a222f..00000000000 --- a/llvm/tools/llvm-reduce/CMakeLists.txt +++ /dev/null @@ -1,24 +0,0 @@ -set(LLVM_LINK_COMPONENTS - AllTargetsAsmParsers - AllTargetsCodeGens - AllTargetsDescs - AllTargetsInfos - IRReader - Support - Target - TransformUtils - ) - -# Support plugins. -set(LLVM_NO_DEAD_STRIP 1) - -add_llvm_tool(llvm-reduce - llvm-reduce.cpp - TestRunner.cpp - deltas/Delta.cpp - deltas/ReduceFunctions.cpp - - DEPENDS - intrinsics_gen - ) -export_executable_symbols(llvm-reduce) diff --git a/llvm/tools/llvm-reduce/DeltaManager.h b/llvm/tools/llvm-reduce/DeltaManager.h deleted file mode 100644 index 28d1cd989e3..00000000000 --- a/llvm/tools/llvm-reduce/DeltaManager.h +++ /dev/null @@ -1,25 +0,0 @@ -//===- DeltaManager.h - Runs Delta Passes to reduce Input -----------------===// -// -// 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 calls each specialized Delta pass in order to reduce the input IR -// file. -// -//===----------------------------------------------------------------------===// - -#include "TestRunner.h" -#include "deltas/Delta.h" -#include "deltas/ReduceFunctions.h" - -namespace llvm { - -inline void runDeltaPasses(TestRunner &Tester) { - reduceFunctionsDeltaPass(Tester); - // TODO: Implement the remaining Delta Passes -} - -} // namespace llvm diff --git a/llvm/tools/llvm-reduce/LLVMBuild.txt b/llvm/tools/llvm-reduce/LLVMBuild.txt deleted file mode 100644 index 7928f050328..00000000000 --- a/llvm/tools/llvm-reduce/LLVMBuild.txt +++ /dev/null @@ -1,24 +0,0 @@ -;===- ./tools/llvm-reduce/LLVMBuild.txt ------------------------*- Conf -*--===; -; -; 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 is an LLVMBuild description file for the components in this subdirectory. -; -; For more information on the LLVMBuild system, please see: -; -; http://llvm.org/docs/LLVMBuild.html -; -;===------------------------------------------------------------------------===; - -[component_0] -type = Tool -name = llvm-reduce -parent = Tools -required_libraries = - BitReader - IRReader - all-targets diff --git a/llvm/tools/llvm-reduce/TestRunner.cpp b/llvm/tools/llvm-reduce/TestRunner.cpp deleted file mode 100644 index 06fb4da733b..00000000000 --- a/llvm/tools/llvm-reduce/TestRunner.cpp +++ /dev/null @@ -1,60 +0,0 @@ -//===-- TestRunner.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 -// -//===----------------------------------------------------------------------===// - -#include "TestRunner.h" -#include <utility> - -using namespace llvm; - -/// Gets Current Working Directory and tries to create a Tmp Directory -static SmallString<128> initializeTmpDirectory() { - SmallString<128> CWD; - if (std::error_code EC = sys::fs::current_path(CWD)) { - errs() << "Error getting current directory: " << EC.message() << "!\n"; - exit(1); - } - - SmallString<128> TmpDirectory; - sys::path::append(TmpDirectory, CWD, "tmp"); - if (std::error_code EC = sys::fs::create_directory(TmpDirectory)) - errs() << "Error creating tmp directory: " << EC.message() << "!\n"; - - return TmpDirectory; -} - -TestRunner::TestRunner(StringRef TestName, std::vector<std::string> TestArgs, - StringRef ReducedFilepath) - : TestName(TestName), TestArgs(std::move(TestArgs)), - ReducedFilepath(ReducedFilepath) { - TmpDirectory = initializeTmpDirectory(); -} - -/// Runs the interestingness test, passes file to be tested as first argument -/// and other specified test arguments after that. -int TestRunner::run(StringRef Filename) { - std::vector<StringRef> ProgramArgs; - ProgramArgs.push_back(TestName); - ProgramArgs.push_back(Filename); - - for (auto Arg : TestArgs) - ProgramArgs.push_back(Arg.c_str()); - for (unsigned I = 0, E = ProgramArgs.size(); I != E; ++I) - outs() << ProgramArgs[I] << "\n"; - StringRef SR = ""; - Optional<StringRef> Redirects[3] = {SR, SR, SR}; // STDIN, STDOUT, STDERR - int Result = sys::ExecuteAndWait(TestName, ProgramArgs, None, Redirects); - - if (Result < 0) { - Error E = make_error<StringError>("Error running interesting-ness test\n", - inconvertibleErrorCode()); - outs() << toString(std::move(E)); - exit(1); - } - - return !Result; -} diff --git a/llvm/tools/llvm-reduce/TestRunner.h b/llvm/tools/llvm-reduce/TestRunner.h deleted file mode 100644 index 4d5b5bb0375..00000000000 --- a/llvm/tools/llvm-reduce/TestRunner.h +++ /dev/null @@ -1,56 +0,0 @@ -//===-- tools/llvm-reduce/TestRunner.h ---------------------------*- C++ -*-===/ -// -// 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 -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_TOOLS_LLVMREDUCE_TESTRUNNER_H -#define LLVM_TOOLS_LLVMREDUCE_TESTRUNNER_H - -#include "llvm/ADT/SmallString.h" -#include "llvm/IR/Module.h" -#include "llvm/Support/Error.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/Program.h" -#include <vector> - -namespace llvm { - -// This class contains all the info necessary for running the provided -// interesting-ness test, as well as the most reduced module and its -// respective filename. -class TestRunner { -public: - TestRunner(StringRef TestName, std::vector<std::string> TestArgs, - StringRef ReducedFilepath); - - /// Runs the interesting-ness test for the specified file - /// @returns 0 if test was successful, 1 if otherwise - int run(StringRef Filename); - - /// Filename to the most reduced testcase - StringRef getReducedFilepath() const { return ReducedFilepath; } - /// Directory where tmp files are created - StringRef getTmpDir() const { return TmpDirectory; } - /// Returns the most reduced version of the original testcase - Module *getProgram() const { return Program.get(); } - - void setReducedFilepath(SmallString<128> F) { - ReducedFilepath = std::move(F); - } - void setProgram(std::unique_ptr<Module> P) { Program = std::move(P); } - -private: - SmallString<128> TestName; - std::vector<std::string> TestArgs; - SmallString<128> ReducedFilepath; - SmallString<128> TmpDirectory; - std::unique_ptr<Module> Program; -}; - -} // namespace llvm - -#endif diff --git a/llvm/tools/llvm-reduce/deltas/Delta.cpp b/llvm/tools/llvm-reduce/deltas/Delta.cpp deleted file mode 100644 index 9ff0a781089..00000000000 --- a/llvm/tools/llvm-reduce/deltas/Delta.cpp +++ /dev/null @@ -1,203 +0,0 @@ -//===- Delta.cpp - Delta Debugging Algorithm Implementation ---------------===// -// -// 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 the implementation for the Delta Debugging Algorithm: -// it splits a given set of Targets (i.e. Functions, Instructions, BBs, etc.) -// into chunks and tries to reduce the number chunks that are interesting. -// -//===----------------------------------------------------------------------===// - -#include "Delta.h" -#include "llvm/Transforms/Utils/Cloning.h" - -/// Writes IR code to the given Filepath -static bool writeProgramToFile(StringRef Filepath, int FD, const Module &M) { - ToolOutputFile Out(Filepath, FD); - M.print(Out.os(), /*AnnotationWriter=*/nullptr); - Out.os().close(); - - if (!Out.os().has_error()) { - Out.keep(); - return false; - } - return true; -} - -/// Creates a temporary (and unique) file inside the tmp folder and writes -/// the given module IR. -static SmallString<128> createTmpFile(Module *M, StringRef TmpDir) { - SmallString<128> UniqueFilepath; - int UniqueFD; - - std::error_code EC = sys::fs::createUniqueFile(TmpDir + "/tmp-%%%.ll", - UniqueFD, UniqueFilepath); - if (EC) { - errs() << "Error making unique filename: " << EC.message() << "!\n"; - exit(1); - } - - if (writeProgramToFile(UniqueFilepath, UniqueFD, *M)) { - errs() << "Error emitting bitcode to file '" << UniqueFilepath << "'!\n"; - exit(1); - } - return UniqueFilepath; -} - -/// Prints the Chunk Indexes with the following format: [start, end], if -/// chunk is at minimum size (1), then it just displays [start]. -static void printChunks(std::vector<Chunk> Chunks, bool Oneline = false) { - if (Chunks.empty()) { - outs() << "No Chunks"; - return; - } - - for (auto C : Chunks) { - if (!Oneline) - outs() << '\t'; - C.print(); - if (!Oneline) - outs() << '\n'; - } -} - -/// Counts the amount of lines for a given file -static unsigned getLines(StringRef Filepath) { - unsigned Lines = 0; - std::string CurrLine; - std::ifstream FileStream(Filepath); - - while (std::getline(FileStream, CurrLine)) - ++Lines; - - return Lines; -} - -/// Splits Chunks in half and prints them. -/// If unable to split (when chunk size is 1) returns false. -static bool increaseGranularity(std::vector<Chunk> &Chunks) { - outs() << "Increasing granularity..."; - std::vector<Chunk> NewChunks; - bool SplitOne = false; - - for (auto &C : Chunks) { - if (C.end - C.begin == 0) - NewChunks.push_back(C); - else { - unsigned Half = (C.begin + C.end) / 2; - NewChunks.push_back({C.begin, Half}); - NewChunks.push_back({Half + 1, C.end}); - SplitOne = true; - } - } - if (SplitOne) { - Chunks = NewChunks; - outs() << "Success! New Chunks:\n"; - printChunks(Chunks); - } - return SplitOne; -} - -bool llvm::runTestWithoutChunks( - TestRunner &Test, std::function<void(const std::vector<Chunk> &, Module *)> - ExtractChunksFromModule) { - std::unique_ptr<Module> Clone = CloneModule(*Test.getProgram()); - - // Generate Module with only Targets inside Current Chunks - ExtractChunksFromModule({}, Clone.get()); - // Write Module to tmp file - SmallString<128> CurrentFilepath = - createTmpFile(Clone.get(), Test.getTmpDir()); - outs() << " | " << sys::path::filename(CurrentFilepath); - - // Completely reduced Program isn't interesting - if (!Test.run(CurrentFilepath)) - return false; - - // Hooray! We reduced the testcase completely - Test.setReducedFilepath(CurrentFilepath); - Test.setProgram(std::move(Clone)); - return true; -} - -/// Runs the Delta Debugging algorithm, splits the code into chunks and -/// reduces the amount of chunks that are considered interesting by the -/// given test. -void llvm::runDeltaPass( - TestRunner &Test, unsigned Targets, - std::function<void(const std::vector<Chunk> &, Module *)> - ExtractChunksFromModule) { - if (!Targets) - return; - - std::vector<Chunk> Chunks = {{1, Targets}}; - std::set<Chunk> UninterestingChunks; - std::unique_ptr<Module> ReducedProgram; - - if (!Test.run(Test.getReducedFilepath())) { - outs() << "\nInput isn't interesting! Verify interesting-ness test\n"; - outs() << "----------------------------\n"; - return; - } - - if (!increaseGranularity(Chunks)) { - outs() << "\nCan't reduce anymore\n"; - outs() << "----------------------------\n"; - return; - } - - do { - UninterestingChunks = {}; - for (int I = Chunks.size() - 1; I >= 0; --I) { - std::vector<Chunk> CurrentChunks; - - for (auto C : Chunks) - if (!UninterestingChunks.count(C) && C != Chunks[I]) - CurrentChunks.push_back(C); - - if (CurrentChunks.empty()) - continue; - - // Clone module before hacking it up.. - std::unique_ptr<Module> CurrentProgram = CloneModule(*Test.getProgram()); - // Generate Module with only Targets inside Current Chunks - ExtractChunksFromModule(CurrentChunks, CurrentProgram.get()); - // Write Module to tmp file - SmallString<128> CurrentFilepath = - createTmpFile(CurrentProgram.get(), Test.getTmpDir()); - - outs() << "Testing with: "; - printChunks(CurrentChunks, /*Oneline=*/true); - outs() << " | " << sys::path::filename(CurrentFilepath); - - // Current Chunks aren't interesting - if (!Test.run(CurrentFilepath)) { - outs() << "\n"; - continue; - } - - UninterestingChunks.insert(Chunks[I]); - Test.setReducedFilepath(CurrentFilepath); - ReducedProgram = std::move(CurrentProgram); - outs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath) << "\n"; - } - // Delete uninteresting chunks - auto UnwantedChunks = Chunks.end(); - UnwantedChunks = std::remove_if(Chunks.begin(), Chunks.end(), - [UninterestingChunks](const Chunk &C) { - return UninterestingChunks.count(C); - }); - Chunks.erase(UnwantedChunks, Chunks.end()); - - } while (!UninterestingChunks.empty() || increaseGranularity(Chunks)); - - // If we reduced the testcase replace it - if (ReducedProgram) - Test.setProgram(std::move(ReducedProgram)); - outs() << "Couldn't increase anymore.\n"; - outs() << "----------------------------\n"; -}
\ No newline at end of file diff --git a/llvm/tools/llvm-reduce/deltas/Delta.h b/llvm/tools/llvm-reduce/deltas/Delta.h deleted file mode 100644 index 9078ebd8ef0..00000000000 --- a/llvm/tools/llvm-reduce/deltas/Delta.h +++ /dev/null @@ -1,89 +0,0 @@ -//===- Delta.h - Delta Debugging Algorithm Implementation -----------------===// -// -// 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 the implementation for the Delta Debugging Algorithm: -// it splits a given set of Targets (i.e. Functions, Instructions, BBs, etc.) -// into chunks and tries to reduce the number chunks that are interesting. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_TOOLS_LLVMREDUCE_LLVMREDUCE_DELTA_H -#define LLVM_TOOLS_LLVMREDUCE_LLVMREDUCE_DELTA_H - -#include "../TestRunner.h" -#include "llvm/IR/Verifier.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/Path.h" -#include "llvm/Support/ScopedPrinter.h" -#include "llvm/Support/ToolOutputFile.h" -#include "llvm/Transforms/Utils/Cloning.h" -#include <fstream> -#include <set> -#include <vector> - -using namespace llvm; - -struct Chunk { - unsigned begin; - unsigned end; - - /// Helper function to verify if a given Target-index is inside the Chunk - bool contains(unsigned Index) const { return Index >= begin && Index <= end; } - - void print() const { - outs() << "[" << begin; - if (end - begin != 0) - outs() << "," << end; - outs() << "]"; - } - - /// Operator when populating CurrentChunks in Generic Delta Pass - friend bool operator!=(const Chunk &C1, const Chunk &C2) { - return C1.begin != C2.begin || C1.end != C2.end; - } - - /// Operator used for sets - friend bool operator<(const Chunk &C1, const Chunk &C2) { - return std::tie(C1.begin, C1.end) < std::tie(C2.begin, C2.end); - } -}; - -namespace llvm { - -/// This function implements the Delta Debugging algorithm, it receives a -/// number of Targets (e.g. Functions, Instructions, Basic Blocks, etc.) and -/// splits them in half; these chunks of targets are then tested while ignoring -/// one chunk, if a chunk is proven to be uninteresting (i.e. fails the test) -/// it is removed from consideration. The algorithm will attempt to split the -/// Chunks in half and start the process again until it can't split chunks -/// anymore. -/// -/// This function is intended to be called by each specialized delta pass (e.g. -/// RemoveFunctions) and receives three key parameters: -/// * Test: The main TestRunner instance which is used to run the provided -/// interesting-ness test, as well as to store and access the reduced Program. -/// * Targets: The amount of Targets that are going to be reduced by the -/// algorithm, for example, the RemoveGlobalVars pass would send the amount of -/// initialized GVs. -/// * ExtractChunksFromModule: A function used to tailor the main program so it -/// only contains Targets that are inside Chunks of the given iteration. -/// Note: This function is implemented by each specialized Delta pass -/// -/// Other implementations of the Delta Debugging algorithm can also be found in -/// the CReduce, Delta, and Lithium projects. -void runDeltaPass(TestRunner &Test, unsigned Targets, - std::function<void(const std::vector<Chunk> &, Module *)> - ExtractChunksFromModule); - -bool runTestWithoutChunks( - TestRunner &Test, std::function<void(const std::vector<Chunk> &, Module *)> - ExtractChunksFromModule); - -} // namespace llvm - -#endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp b/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp deleted file mode 100644 index bf0e07f34ab..00000000000 --- a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp +++ /dev/null @@ -1,80 +0,0 @@ -//===- ReduceFunctions.cpp - Specialized Delta Pass -----------------------===// -// -// 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 a function which calls the Generic Delta pass in order -// to reduce functions (and any instruction that calls it) in the provided -// Module. -// -//===----------------------------------------------------------------------===// - -#include "ReduceFunctions.h" - -/// Removes all the Defined Functions (as well as their calls) -/// that aren't inside any of the desired Chunks. -/// @returns the Module stripped of out-of-chunk functions -static void extractFunctionsFromModule(const std::vector<Chunk> &ChunksToKeep, - Module *Program) { - // Get functions inside desired chunks - std::set<Function *> FuncsToKeep; - unsigned I = 0, FunctionCount = 0; - for (auto &F : *Program) { - if (!F.isDeclaration() && I < ChunksToKeep.size()) { - if (ChunksToKeep[I].contains(++FunctionCount)) - FuncsToKeep.insert(&F); - if (FunctionCount == ChunksToKeep[I].end) - ++I; - } - } - - // Delete out-of-chunk functions, and replace their calls with undef - std::vector<Function *> FuncsToRemove; - for (auto &F : *Program) { - if (!F.isDeclaration() && !FuncsToKeep.count(&F)) { - F.replaceAllUsesWith(UndefValue::get(F.getType())); - FuncsToRemove.push_back(&F); - } - } - for (auto *F : FuncsToRemove) - F->eraseFromParent(); - - // Delete instructions with undef calls - std::vector<Instruction *> InstToRemove; - for (auto &F : *Program) - for (auto &BB : F) - for (auto &I : BB) - if (auto *Call = dyn_cast<CallInst>(&I)) - if (!Call->getCalledFunction()) { - // Instruction might be stored / used somewhere else - I.replaceAllUsesWith(UndefValue::get(I.getType())); - InstToRemove.push_back(&I); - } - - for (auto *I : InstToRemove) - I->eraseFromParent(); -} - -/// Counts the amount of non-declaration functions and prints their -/// respective name & index -static unsigned countDefinedFunctions(Module *Program) { - // TODO: Silence index with --quiet flag - outs() << "----------------------------\n"; - outs() << "Function Index Reference:\n"; - unsigned FunctionCount = 0; - for (auto &F : *Program) - if (!F.isDeclaration()) - outs() << "\t" << ++FunctionCount << ": " << F.getName() << "\n"; - - outs() << "----------------------------\n"; - return FunctionCount; -} - -void llvm::reduceFunctionsDeltaPass(TestRunner &Test) { - outs() << "*** Reducing Functions...\n"; - unsigned Functions = countDefinedFunctions(Test.getProgram()); - runDeltaPass(Test, Functions, extractFunctionsFromModule); -}
\ No newline at end of file diff --git a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h b/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h deleted file mode 100644 index 7c2cd3f33e9..00000000000 --- a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h +++ /dev/null @@ -1,20 +0,0 @@ -//===- ReduceFunctions.h - Specialized Delta Pass -------------------------===// -// -// 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 a function which calls the Generic Delta pass in order -// to reduce functions (and any instruction that calls it) in the provided -// Module. -// -//===----------------------------------------------------------------------===// - -#include "Delta.h" -#include "llvm/Transforms/Utils/Cloning.h" - -namespace llvm { -void reduceFunctionsDeltaPass(TestRunner &Test); -} // namespace llvm diff --git a/llvm/tools/llvm-reduce/llvm-reduce.cpp b/llvm/tools/llvm-reduce/llvm-reduce.cpp deleted file mode 100644 index 6dd733edecb..00000000000 --- a/llvm/tools/llvm-reduce/llvm-reduce.cpp +++ /dev/null @@ -1,105 +0,0 @@ -//===- llvm-reduce.cpp - The LLVM Delta Reduction utility -----------------===// -// -// 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 program tries to reduce an IR test case for a given interesting-ness -// test. It runs multiple delta debugging passes in order to minimize the input -// file. It's worth noting that this is a *temporary* tool that will eventually -// be integrated into the bugpoint tool itself. -// -//===----------------------------------------------------------------------===// - -#include "DeltaManager.h" -#include "llvm/ADT/SmallString.h" -#include "llvm/IR/LLVMContext.h" -#include "llvm/IR/Verifier.h" -#include "llvm/IRReader/IRReader.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/InitLLVM.h" -#include "llvm/Support/SourceMgr.h" -#include "llvm/Support/raw_ostream.h" -#include <system_error> -#include <vector> - -using namespace llvm; - -static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden); -static cl::opt<bool> Version("v", cl::desc("Alias for -version"), cl::Hidden); - -static cl::opt<std::string> InputFilename(cl::Positional, cl::Required, - cl::desc("<input llvm ll/bc file>")); - -static cl::opt<std::string> - TestFilename("test", cl::Required, - cl::desc("Name of the interesting-ness test to be run")); - -static cl::list<std::string> - TestArguments("test-arg", cl::ZeroOrMore, - cl::desc("Arguments passed onto the interesting-ness test")); - -static cl::opt<std::string> - OutputFilename("output", - cl::desc("Specify the output file. default: reduced.ll")); -static cl::alias OutputFileAlias("o", cl::desc("Alias for -output"), - cl::aliasopt(OutputFilename)); - -static cl::opt<bool> - ReplaceInput("in-place", - cl::desc("WARNING: This option will replace your input file" - "with the reduced version!")); - -// Parses IR into a Module and verifies it -static std::unique_ptr<Module> parseInputFile(StringRef Filename, - LLVMContext &Ctxt) { - SMDiagnostic Err; - std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt); - if (!Result) { - Err.print("llvm-reduce", errs()); - return Result; - } - - if (verifyModule(*Result, &errs())) { - errs() << "Error: " << Filename << " - input module is broken!\n"; - return std::unique_ptr<Module>(); - } - - return Result; -} - -int main(int argc, char **argv) { - InitLLVM X(argc, argv); - - cl::ParseCommandLineOptions(argc, argv, "LLVM automatic testcase reducer.\n"); - - LLVMContext Context; - std::unique_ptr<Module> OriginalProgram = - parseInputFile(InputFilename, Context); - - // Initialize test environment - TestRunner Tester(TestFilename, TestArguments, InputFilename); - Tester.setProgram(std::move(OriginalProgram)); - - // Try to reduce code - runDeltaPasses(Tester); - StringRef ReducedFilename = sys::path::filename(Tester.getReducedFilepath()); - - if (ReducedFilename == InputFilename) { - outs() << "\nCouldnt reduce input :/\n"; - } else { - if (ReplaceInput) // In-place - OutputFilename = InputFilename.c_str(); - else if (OutputFilename.empty()) - OutputFilename = "reduced.ll"; - else - OutputFilename += ".ll"; - - sys::fs::copy_file(Tester.getReducedFilepath(), OutputFilename); - outs() << "\nDone reducing! Reduced IR to file: " << OutputFilename << "\n"; - } - - return 0; -} |
