FNegTests.cpp

Go to the documentation of this file.

/*
 * Copyright 2022 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#include <gtest/gtest.h>
 
#include <jlm/llvm/frontend/LlvmModuleConversion.hpp>
#include <jlm/llvm/ir/operators/call.hpp>
#include <jlm/llvm/ir/operators/operators.hpp>
#include <jlm/llvm/ir/print.hpp>
 
#include <llvm/IR/BasicBlock.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Module.h>
 
template<class OP>
static bool
Contains(const jlm::llvm::InterProceduralGraphModule & module, const std::string &)
{
  using namespace jlm;
 
  bool hasInstruction = false;
  auto controlFlowGraph =
      dynamic_cast<const jlm::llvm::FunctionNode *>(module.ipgraph().find("f"))->cfg();
  auto basicBlock =
      dynamic_cast<const jlm::llvm::BasicBlock *>(controlFlowGraph->entry()->OutEdge(0)->sink());
  for (auto threeAddressCode : *basicBlock)
    hasInstruction = hasInstruction || jlm::llvm::is<OP>(threeAddressCode);
 
  return hasInstruction;
}
 
TEST(FNegTests, TestFNegScalar)
{
  auto Setup = [](llvm::LLVMContext & context)
  {
    using namespace llvm;
 
    std::unique_ptr<Module> module(new Module("module", context));
 
    auto doubleType = Type::getDoubleTy(context);
 
    auto functionArguments = std::vector<Type *>({ doubleType });
    auto functionType = FunctionType::get(doubleType, functionArguments, false);
    auto function = Function::Create(functionType, GlobalValue::ExternalLinkage, "f", module.get());
 
    auto basicBlock = BasicBlock::Create(context, "basicBlock", function);
 
    IRBuilder<> builder(basicBlock);
    auto returnValue = builder.CreateFNeg(function->arg_begin());
    builder.CreateRet(returnValue);
 
    return module;
  };
 
  llvm::LLVMContext context;
  auto llvmModule = Setup(context);
  llvmModule->print(llvm::errs(), nullptr);
 
  auto ipgModule = jlm::llvm::ConvertLlvmModule(*llvmModule);
  print(*ipgModule, stdout);
 
  EXPECT_TRUE(Contains<jlm::llvm::FNegOperation>(*ipgModule, "f"));
}
 
TEST(FNegTests, TestFNegVector)
{
  auto Setup = [](llvm::LLVMContext & context)
  {
    using namespace llvm;
 
    std::unique_ptr<Module> module(new Module("module", context));
 
    auto vectorType = VectorType::get(Type::getDoubleTy(context), 2, false);
 
    auto functionArguments = std::vector<Type *>({ vectorType });
    auto functionType = FunctionType::get(vectorType, functionArguments, false);
    auto function = Function::Create(functionType, GlobalValue::ExternalLinkage, "f", module.get());
 
    auto basicBlock = BasicBlock::Create(context, "basicBlock", function);
 
    IRBuilder<> builder(basicBlock);
    auto returnValue = builder.CreateFNeg(function->arg_begin());
    builder.CreateRet(returnValue);
 
    return module;
  };
 
  llvm::LLVMContext context;
  auto llvmModule = Setup(context);
  llvmModule->print(llvm::errs(), nullptr);
 
  auto ipgModule = jlm::llvm::ConvertLlvmModule(*llvmModule);
  print(*ipgModule, stdout);
 
  EXPECT_TRUE(Contains<jlm::llvm::VectorUnaryOperation>(*ipgModule, "f"));
}