//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- 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
//
//===----------------------------------------------------------------------===//
// Modifications Copyright (c) 2019 Advanced Micro Devices, Inc. All rights reserved.
// Notified per clause 4(b) of the license.
//
//===----------------------------------------------------------------------===//
//               Copyright (c) 2015 Advanced Micro Devices, Inc.
//               All rights reserved.
//               Developed by: Advanced Micro Devices, Inc.
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// with the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is furnished
// to do so, subject to the following conditions:
// Redistributions of source code must retain the above copyright notice, this list
// of conditions and the following disclaimers.
// Redistributions in binary form must reproduce the above copyright notice, this
// list of conditions and the following disclaimers in the documentation and/or
// other materials provided with the distribution.
// Neither the names of Advanced Micro Devices, Inc., nor the names of its
// contributors may be used to endorse or promote products derived from this Software
// without specific prior written permission.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS
// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS WITH THE SOFTWARE.
//===----------------------------------------------------------------------===//
//
// This header file defines prototypes for accessor functions that expose passes
// in the IPO transformations library.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_TRANSFORMS_IPO_H
#define LLVM_TRANSFORMS_IPO_H

#include "llvm/ADT/SmallVector.h"
#include <functional>
#include <vector>

namespace llvm {

class ModulePass;
class Pass;
class raw_ostream;



//===----------------------------------------------------------------------===//
//
// This transforms indirect calls to direct calls.
//
ModulePass *createPadMallocTransformPass();
ModulePass *createIndirectToDirectCallTransformLegacyPass(bool I2DByCloning = false);

//===----------------------------------------------------------------------===//
//
// This pass enables inter procedural alignment check optimization
//
ModulePass *createOptimizeAlignChecksLegacyPass();

//===----------------------------------------------------------------------===//
//
// This pass enables inlining to recursive function.
//
ModulePass *createInlineRecursionLegacyPass(int OptLevel = 2);

//===----------------------------------------------------------------------===//
//
// Speacilize Function For Loop Vectorization
//
ModulePass *createLVFunctionSpecializeLegacyPass();

//===----------------------------------------------------------------------===//
//
// This pass is a test pass for IPAA.
//
ModulePass *createIPAAPassPass();

//===----------------------------------------------------------------------===//
//
// Loop Splitting Pass
//
ModulePass *createLoopSplittingLegacyPass(); // AOCC Line

ModulePass *createAROPass();


//===----------------------------------------------------------------------===//
/// createStructurePeelingPass - This function returns a new pass that
/// transforms Array of structures to Structure of Arrays.
///
ModulePass *createStructurePeelingPass(int StructPeelPtrSize = 0,
    int StructPeelMemBlockSize = 0, int StructLayout = 1);  //AOCC

//===----------------------------------------------------------------------===//
/// createHandleMemFuncsPass - This function returns a new pass that
/// helps to lock/unlock Alloc routines which return struct ptrs.
///
ModulePass *createHandleMemFuncsPass(int RefVal = 0); //AOCC

ModulePass *createDArrOpEPass(); //AOCC

ModulePass *createDAopOpEPass(); // AOCC

ModulePass *createArrayDFAPass(int AnalyTy = 0); // AOCC

ModulePass* createGlobSTyConstPropPass(); // AOCC

ModulePass *createMarkFuncsPass(); //AOCC

//===----------------------------------------------------------------------===//
/// createDeadArgEliminationPass - This pass removes arguments from functions
/// which are not used by the body of the function.
///
ModulePass *createDeadArgEliminationPass();

/// DeadArgHacking pass - Same as DAE, but delete arguments of external
/// functions as well.  This is definitely not safe, and should only be used by
/// bugpoint.
ModulePass *createDeadArgHackingPass();

//===----------------------------------------------------------------------===//
//
/// createLoopExtractorPass - This pass extracts all natural loops from the
/// program into a function if it can.
///
Pass *createLoopExtractorPass();

/// createSingleLoopExtractorPass - This pass extracts one natural loop from the
/// program into a function if it can.  This is used by bugpoint.
///
Pass *createSingleLoopExtractorPass();

//===----------------------------------------------------------------------===//
/// createBarrierNoopPass - This pass is purely a module pass barrier in a pass
/// manager.
ModulePass *createBarrierNoopPass();

/// What to do with the summary when running passes that operate on it.
enum class PassSummaryAction {
  None,   ///< Do nothing.
  Import, ///< Import information from summary.
  Export, ///< Export information to summary.
};

/// Specialize function calls with constant actuals.
ModulePass *createFunctionSpecializePass();

/// Outline early return from functions to avoid call overhead.
ModulePass *createOutlineEarlyReturnPass();

} // End llvm namespace

#endif
