c_writer.hpp

Go to the documentation of this file.

/*
 *
 *                   _/_/_/    _/_/   _/    _/ _/_/_/    _/_/
 *                  _/   _/ _/    _/ _/_/  _/ _/   _/ _/    _/
 *                 _/_/_/  _/_/_/_/ _/  _/_/ _/   _/ _/_/_/_/
 *                _/      _/    _/ _/    _/ _/   _/ _/    _/
 *               _/      _/    _/ _/    _/ _/_/_/  _/    _/
 *
 *             ***********************************************
 *                              PandA Project
 *                     URL: http://panda.dei.polimi.it
 *                       Politecnico di Milano - DEIB
 *                        System Architectures Group
 *             ***********************************************
 *              Copyright (C) 2004-2024 Politecnico di Milano
 *
 *   This file is part of the PandA framework.
 *
 *   The PandA framework is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef CWRITER_HPP
#define CWRITER_HPP

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "graph.hpp"
#include "refcount.hpp"

#include <deque>
#include <list>
#include <vector>

CONSTREF_FORWARD_DECL(BBGraph);
CONSTREF_FORWARD_DECL(BBNodeInfo);
CONSTREF_FORWARD_DECL(BehavioralHelper);
CONSTREF_FORWARD_DECL(CBackendInformation);
CONSTREF_FORWARD_DECL(FunctionBehavior);
CONSTREF_FORWARD_DECL(InstructionWriter);
CONSTREF_FORWARD_DECL(HLS_manager);
CONSTREF_FORWARD_DECL(OpGraph);
CONSTREF_FORWARD_DECL(Parameter);
CONSTREF_FORWARD_DECL(tree_manager);
CONSTREF_FORWARD_DECL(tree_node);
CONSTREF_FORWARD_DECL(var_pp_functor);
REF_FORWARD_DECL(CWriter);
REF_FORWARD_DECL(IndentedOutputStream);
REF_FORWARD_DECL(InstructionWriter);
REF_FORWARD_DECL(Loop);
REF_FORWARD_DECL(machine_node);

class OpVertexSet;
class graph;
class instrumented_call_instr_writer;

template <typename Graph>
class dominance;

class CWriter
{
 protected:
   const HLS_managerConstRef HLSMgr;

   const tree_managerConstRef TM;

   const IndentedOutputStreamRef indented_output_stream;

   CustomSet<std::string> globally_declared_types;

   CustomSet<unsigned int> globallyDeclVars;

   const InstructionWriterRef instrWriter;

   size_t bb_label_counter;

   bool verbose;

   const ParameterConstRef Param;

   int debug_level;

   int output_level;

   unsigned int fake_max_tree_node_id;

   std::map<unsigned int, std::string> basic_block_prefix;

   std::map<unsigned int, std::string> basic_block_tail;

   std::map<vertex, std::map<unsigned int, std::string>> renaming_table;

   CustomOrderedSet<vertex> bb_frontier;
   CustomOrderedSet<vertex> bb_analyzed;
   std::map<unsigned int, std::string> basic_blocks_labels;
   CustomOrderedSet<vertex> goto_list;
   var_pp_functorConstRef local_rec_variableFunctor;
   FunctionBehaviorConstRef local_rec_function_behavior;
   CustomOrderedSet<vertex> local_rec_instructions;
   const dominance<BBGraph>* dominators;
   const dominance<BBGraph>* post_dominators;
   BBGraphConstRef local_rec_bb_fcfgGraph;
   OpGraphConstRef local_rec_cfgGraph;
   BehavioralHelperConstRef local_rec_behavioral_helper;
   void writeRoutineInstructions_rec(vertex current_vertex, bool bracket, const unsigned int function_index);

   virtual void writePreInstructionInfo(const FunctionBehaviorConstRef, const vertex);

   virtual void writePostInstructionInfo(const FunctionBehaviorConstRef, const vertex);

   virtual void WriteBodyLoop(const unsigned int function_index, const unsigned int, vertex current_vertex,
                              bool bracket);

   void compute_phi_nodes(const FunctionBehaviorConstRef function_behavior, const OpVertexSet& instructions,
                          var_pp_functorConstRef variableFunctor);

   std::vector<std::string> additionalIncludes;
   CustomOrderedSet<std::string> writtenIncludes;

   void insert_copies(vertex b, const BBGraphConstRef bb_domGraph, const BBGraphConstRef bb_fcfgGraph,
                      var_pp_functorConstRef variableFunctor, const CustomSet<unsigned int>& phi_instructions,
                      std::map<unsigned int, unsigned int>& created_variables,
                      std::map<unsigned int, std::string>& symbol_table,
                      std::map<unsigned int, std::deque<std::string>>& array_of_stacks);

   void schedule_copies(vertex b, const BBGraphConstRef bb_domGraph, const BBGraphConstRef bb_fcfgGraph,
                        var_pp_functorConstRef variableFunctor, const CustomSet<unsigned int>& phi_instructions,
                        std::map<unsigned int, unsigned int>& created_variables,
                        std::map<unsigned int, std::string>& symbol_table, std::list<unsigned int>& pushed,
                        std::map<unsigned int, std::deque<std::string>>& array_of_stacks);

   unsigned int create_new_identifier(std::map<unsigned int, std::string>& symbol_table);

   void push_stack(std::string symbol_name, unsigned int dest_i, std::list<unsigned int>& pushed,
                   std::map<unsigned int, std::deque<std::string>>& array_of_stacks);

   void pop_stack(std::list<unsigned int>& pushed, std::map<unsigned int, std::deque<std::string>>& array_of_stacks);

   void WriteHashTableImplementation();

   /*
    * writes code at the beginning of the basic block denoted by the
    * identifier bb_number in the function function_index.
    * the code is written before all the instructions
    * of the BB, but after the goto label of the BB (if present)
    */
   virtual void WriteBBHeader(const unsigned int bb_number, const unsigned int function_index);

 protected:
   CWriter(const HLS_managerConstRef _HLSMgr, const InstructionWriterRef instruction_writer,
           const IndentedOutputStreamRef indented_output_stream, const ParameterConstRef Param, bool verbose = true);

 public:
   virtual ~CWriter();

   static CWriterRef CreateCWriter(const CBackendInformationConstRef c_backend_information,
                                   const HLS_managerConstRef hls_man,
                                   const IndentedOutputStreamRef indented_output_stream,
                                   const ParameterConstRef parameters, const bool verbose);

   virtual void Initialize();

   const InstructionWriterRef getInstructionWriter() const;

   const CustomSet<unsigned int> GetLocalVariables(const unsigned int function_id) const;

   virtual void WriteFunctionImplementation(unsigned int function_id);

   virtual void StartFunctionBody(const unsigned int function_id);

   virtual void WriteFunctionBody(const unsigned int function_id);

   virtual void EndFunctionBody(unsigned int funId);

   virtual void writeRoutineInstructions(const unsigned int function_index, const OpVertexSet& instructions,
                                         var_pp_functorConstRef variableFunctor, vertex bb_start = NULL_VERTEX,
                                         CustomOrderedSet<vertex> bb_end = CustomOrderedSet<vertex>());

   virtual void WriteFunctionDeclaration(const unsigned int funId);

   virtual void WriteHeader();

   virtual void WriteGlobalDeclarations();

   virtual void writeInclude(const std::string& file_name);

   virtual void DeclareType(const tree_nodeConstRef& varType, const BehavioralHelperConstRef& behavioral_helper,
                            CustomSet<std::string>& locally_declared_type);

   virtual void DeclareVariable(const tree_nodeConstRef& curVar, CustomSet<unsigned int>& already_declared_variables,
                                CustomSet<std::string>& locally_declared_type,
                                const BehavioralHelperConstRef& behavioral_helper,
                                const var_pp_functorConstRef& varFunc);

   virtual void declare_cast_types(unsigned int funId, CustomSet<std::string>& locally_declared_types);

   virtual void DeclareLocalVariables(const CustomSet<unsigned int>& to_be_declared,
                                      CustomSet<unsigned int>& already_declared_variables,
                                      CustomSet<std::string>& already_declared_types,
                                      const BehavioralHelperConstRef behavioral_helper,
                                      const var_pp_functorConstRef varFunc);

   virtual void DeclareFunctionTypes(const tree_nodeConstRef& tn);

   virtual void WriteFile(const std::string& file_name);

   virtual void WriteBuiltinWaitCall();
};

using CWriterRef = refcount<CWriter>;

#endif