compiler_wrapper.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 COMPILER_WRAPPER_HPP
#define COMPILER_WRAPPER_HPP

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

#include <filesystem>
#include <iosfwd>
#include <vector>

REF_FORWARD_DECL(application_manager);
CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(tree_manager);

enum class CompilerWrapper_OptimizationSet
{
   O0,     
   O1,     
   O2,     
   O3,     
   O4,     
   O5,     
   Og,     
   Os,     
   Oz,     
   Ofast,  
   OBAMBU, 
   OSF,    
};

enum class CompilerWrapper_CompilerTarget
{
   CT_NO_COMPILER = 0,
   CT_I386_GCC49 = 16,
   CT_I386_GCC5 = 32,
   CT_I386_GCC6 = 64,
   CT_I386_GCC7 = 128,
   CT_I386_GCC8 = 256,
   CT_I386_CLANG4 = 512,
   CT_I386_CLANG5 = 1024,
   CT_I386_CLANG6 = 2048,
   CT_I386_CLANG7 = 4096,
   CT_I386_CLANG8 = 8192,
   CT_I386_CLANG9 = 16384,
   CT_I386_CLANG10 = 32768,
   CT_I386_CLANG11 = 65536,
   CT_I386_CLANG12 = 131072,
   CT_I386_CLANG13 = 262144,
   CT_I386_CLANG16 = 524288,
   CT_I386_CLANGVVD = 1048576
};

class CompilerWrapper
{
 private:
   class Compiler
   {
    public:
      std::string cpp;

      std::string gcc;

      std::string extra_options;

      std::string empty_plugin_obj;
      std::string empty_plugin_name;

      std::string ssa_plugin_obj;
      std::string ssa_plugin_name;

      std::string expandMemOps_plugin_obj;
      std::string expandMemOps_plugin_name;

      std::string GepiCanon_plugin_obj;
      std::string GepiCanon_plugin_name;

      std::string CSROA_plugin_obj;
      std::string CSROA_plugin_name;

      std::string topfname_plugin_obj;
      std::string topfname_plugin_name;

      std::string ASTAnalyzer_plugin_obj;
      std::string ASTAnalyzer_plugin_name;

      std::string llvm_link;

      std::string llvm_opt;

      bool is_clang;

      Compiler() : is_clang(false)
      {
      }
   };

   const ParameterConstRef Param;

   const CompilerWrapper_CompilerTarget compiler_target;

   const CompilerWrapper_OptimizationSet OS;

   std::string frontend_compiler_parameters;

   std::string compiler_linking_parameters;

   CustomSet<std::string> already_processed_files;

   int output_level;

   int debug_level;

   std::map<std::string, int> parameter_values;

   std::map<std::string, bool> optimization_flags;

   std::map<std::string, int> optimization_values;

   void CompileFile(std::string& input_filename, const std::string& output_file, const std::string& parameters_line,
                    int cm, const std::string& costTable);

   std::string GetAnalyzeCompiler() const;

   void InitializeCompilerParameters();

   void ReadParameters();

   void SetCompilerDefault();

   void SetBambuDefault();

   std::string WriteOptimizationsString();

   const std::string AddSourceCodeIncludes(const std::list<std::string>& source_files) const;

   std::string readExternalSymbols(const std::string& filename) const;

   std::string clang_recipes(const CompilerWrapper_OptimizationSet optimization_level, const std::string& fname) const;

   std::string load_plugin(const std::string& plugin_obj, CompilerWrapper_CompilerTarget target) const;

   std::string load_plugin_opt(std::string plugin_obj, CompilerWrapper_CompilerTarget target) const;

   std::string add_plugin_prefix(CompilerWrapper_CompilerTarget target, std::string O_level = "") const;

 public:
   static std::string bambu_ir_info;

   CompilerWrapper(const ParameterConstRef Param, const CompilerWrapper_CompilerTarget _compiler_target,
                   const CompilerWrapper_OptimizationSet OS);

   ~CompilerWrapper();

   Compiler GetCompiler() const;

   void FillTreeManager(const tree_managerRef TM, std::vector<std::string>& source_files, const std::string& costTable);

   void GetSystemIncludes(std::vector<std::string>& includes) const;

   void GetCompilerConfig() const;

   void QueryCompilerConfig(const std::string& compiler_option) const;

   std::string GetCompilerParameters(const std::string& extra_compiler_options,
                                     bool no_frontend_compiler_parameters = false) const;

   void CreateExecutable(const std::list<std::string>& file_names, const std::string& executable_name,
                         const std::string& extra_compiler_options, bool no_frontend_compiler_parameters = false) const;

   void CreateExecutable(const CustomSet<std::string>& file_names, const std::string& executable_name,
                         const std::string& extra_compiler_options, bool no_frontend_compiler_parameters = false) const;

   void ReadXml(const std::string& file_name);

   void WriteXml(const std::string& file_name) const;

   static std::string WriteOptimizationLevel(const CompilerWrapper_OptimizationSet optimization_level);

   static size_t CGetPointerSize(const ParameterConstRef parameters);

   static bool isCurrentOrNewer(CompilerWrapper_CompilerTarget ct, CompilerWrapper_CompilerTarget compare);
   static bool isClangCheck(CompilerWrapper_CompilerTarget ct);
   static bool isGccCheck(CompilerWrapper_CompilerTarget ct);
   static int getCompatibleCompilers();
   static int getDefaultCompiler();
   static std::string getCompilerSuffix(CompilerWrapper_CompilerTarget pc);
   static bool hasCompilerM64(CompilerWrapper_CompilerTarget ct);
   static bool hasCompilerMX32(CompilerWrapper_CompilerTarget ct);
   static bool hasCompilerGCCM32(CompilerWrapper_CompilerTarget ct);
   static bool hasCompilerCLANGM32(CompilerWrapper_CompilerTarget ct);
   static std::string getCompilerVersion(int ct);
};

using CompilerWrapperRef = refcount<CompilerWrapper>;
using CompilerWrapperConstRef = refcount<const CompilerWrapper>;

#endif