add-prints.cpp

Go to the documentation of this file.

/*
 * Copyright 2021 David Metz <david.c.metz@ntnu.no>
 * See COPYING for terms of redistribution.
 */
 
#include <jlm/hls/backend/rvsdg2rhls/add-prints.hpp>
#include <jlm/hls/ir/hls.hpp>
#include <jlm/llvm/ir/CallingConvention.hpp>
#include <jlm/llvm/ir/operators/call.hpp>
#include <jlm/llvm/ir/operators/IntegerOperations.hpp>
#include <jlm/llvm/ir/operators/operators.hpp>
#include <jlm/rvsdg/gamma.hpp>
#include <jlm/rvsdg/traverser.hpp>
 
namespace jlm::hls
{
 
void
add_prints(rvsdg::Region * region)
{
  for (auto & node : rvsdg::TopDownTraverser(region))
  {
    if (auto structnode = dynamic_cast<rvsdg::StructuralNode *>(node))
    {
      for (size_t n = 0; n < structnode->nsubregions(); n++)
      {
        add_prints(structnode->subregion(n));
      }
    }
    if (dynamic_cast<jlm::rvsdg::SimpleNode *>(node) && node->noutputs() == 1
        && jlm::rvsdg::is<rvsdg::BitType>(node->output(0)->Type())
        && !jlm::rvsdg::is<llvm::UndefValueOperation>(node))
    {
      auto out = node->output(0);
      std::vector<jlm::rvsdg::Input *> old_users;
      for (auto & user : out->Users())
        old_users.push_back(&user);
      auto new_out = PrintOperation::create(*out)[0];
      for (auto user : old_users)
      {
        user->divert_to(new_out);
      }
    }
  }
}
 
void
add_prints(llvm::LlvmRvsdgModule & rm)
{
  auto & graph = rm.Rvsdg();
  auto root = &graph.GetRootRegion();
  add_prints(root);
}
 
void
convert_prints(llvm::LlvmRvsdgModule & rm)
{
  auto & graph = rm.Rvsdg();
  auto root = &graph.GetRootRegion();
  // TODO: make this less hacky by using the correct state types
  auto fct =
      rvsdg::FunctionType::Create({ rvsdg::BitType::Create(64), rvsdg::BitType::Create(64) }, {});
  auto & printf = llvm::LlvmGraphImport::createFunctionImport(
      graph,
      fct,
      "printnode",
      llvm::Linkage::externalLinkage,
      llvm::CallingConvention::Default);
  convert_prints(root, &printf, fct);
}
 
void
convert_prints(
    rvsdg::Region * region,
    jlm::rvsdg::Output * printf,
    const std::shared_ptr<const rvsdg::FunctionType> & functionType)
{
  for (auto & node : rvsdg::TopDownTraverser(region))
  {
    if (auto structnode = dynamic_cast<rvsdg::StructuralNode *>(node))
    {
      for (size_t n = 0; n < structnode->nsubregions(); n++)
      {
        convert_prints(structnode->subregion(n), printf, functionType);
      }
    }
    else if (auto po = dynamic_cast<const PrintOperation *>(&(node->GetOperation())))
    {
      auto printf_local = &rvsdg::RouteToRegion(*printf,
                                                *region); // TODO: prevent repetition?
      auto & constantNode = llvm::IntegerConstantOperation::Create(*region, 64, po->id());
      jlm::rvsdg::Output * val = node->input(0)->origin();
      if (*val->Type() != *jlm::rvsdg::BitType::Create(64))
      {
        auto bt = std::dynamic_pointer_cast<const rvsdg::BitType>(val->Type());
        JLM_ASSERT(bt);
        val = &llvm::ZExtOperation::Create(*val, rvsdg::BitType::Create(64));
      }
      llvm::CallOperation::Create(printf_local, functionType, { constantNode.output(0), val });
      node->output(0)->divert_users(node->input(0)->origin());
      jlm::rvsdg::remove(node);
    }
  }
}
 
}