Removed an unused field.

src/HLS/hls_manager.cpp

@@ -79,7 +79,7 @@
 #endif
 
 HLS_manager::HLS_manager(const ParameterConstRef _Param, const HLS_targetRef _HLS_T)
-    : application_manager(FunctionExpanderConstRef(new FunctionExpander()), true, false, _Param),
+    : application_manager(FunctionExpanderConstRef(new FunctionExpander()), false, _Param),
       HLS_T(_HLS_T),
       memory_version(1),
       base_address(0),

src/behavior/application_manager.cpp

@@ -73,17 +73,16 @@
 #include "tree_reindex.hpp"
 
 application_manager::application_manager(const FunctionExpanderConstRef function_expander,
-                                         const bool _single_root_function, const bool _allow_recursive_functions,
+                                         const bool _allow_recursive_functions,
                                          const ParameterConstRef _Param)
     : TM(new tree_manager(_Param)),
       call_graph_manager(
-          new CallGraphManager(function_expander, _single_root_function, _allow_recursive_functions, TM, _Param)),
+          new CallGraphManager(function_expander, _allow_recursive_functions, TM, _Param)),
       Param(_Param),
       address_bitsize(
           _Param->isOption(OPT_addr_bus_bitsize) ?
               _Param->getOption<unsigned int>(OPT_addr_bus_bitsize) :
               (_Param->getOption<std::string>(OPT_gcc_m32_mx32).find("-m64") != std::string::npos ? 64 : 32)),
-      single_root_function(_single_root_function),
 #if HAVE_PRAGMA_BUILT
       PM(new pragma_manager(application_managerRef(this, null_deleter()), _Param)),
 #endif

src/behavior/application_manager.hpp

@@ -94,9 +94,6 @@ class application_manager
 
    unsigned int address_bitsize;
 
-   /// True if only one root function has to be considered
-   const bool single_root_function;
-
    /// store memory objects which can be written
    CustomOrderedSet<unsigned int> written_objects;
 
@@ -137,11 +134,10 @@ class application_manager
    /**
     * Constructor
     * @param function_expander is the expander used to determine if a called function has to be examinedi
-    * @param single_root_function specifies if only one root function has to be considered
     * @param allow_recursive_functions specifies if recursive functions are allowed
     * @param _Param is the reference to the class containing all the parameters
     */
-   application_manager(const FunctionExpanderConstRef function_expander, const bool single_root_function,
+   application_manager(const FunctionExpanderConstRef function_expander,
                        const bool allow_recursive_functions, const ParameterConstRef _Param);
 
    /**

src/behavior/call_graph_manager.cpp

@@ -88,13 +88,12 @@
 #define FEEDBACK_SELECTOR 1 << 1
 //@}
 
-CallGraphManager::CallGraphManager(const FunctionExpanderConstRef _function_expander, const bool _single_root_function,
+CallGraphManager::CallGraphManager(const FunctionExpanderConstRef _function_expander,
                                    const bool _allow_recursive_functions, const tree_managerConstRef _tree_manager,
                                    const ParameterConstRef _Param)
     : call_graphs_collection(new CallGraphsCollection(CallGraphInfoRef(new CallGraphInfo()), _Param)),
       call_graph(new CallGraph(call_graphs_collection, STD_SELECTOR | FEEDBACK_SELECTOR)),
       tree_manager(_tree_manager),
-      single_root_function(_single_root_function),
       allow_recursive_functions(_allow_recursive_functions),
       Param(_Param),
       debug_level(_Param->get_class_debug_level(GET_CLASS(*this))),

src/behavior/call_graph_manager.hpp

@@ -87,9 +87,6 @@ class CallGraphManager
    /// put into relation function F_i and the vertex in the call graph representing it
    std::map<unsigned int, vertex> functionID_vertex_map;
 
-   /// True if only
-   const bool single_root_function;
-
    /// True if recursive calls are allowed
    const bool allow_recursive_functions;
 
@@ -155,12 +152,11 @@ class CallGraphManager
     * Constructor. The data structure is initialized.
     * @param function_expander is the functor used to determine if a function has to be considered during construction
     * of call graph
-    * @param single_root_function specifies if only one root function has to be considered
     * @param allow_recursive_functions specifies if recursive functions are allowed
     * @param tree_manager is the tree manager
     * @param Param is the set of input parameters
     */
-   CallGraphManager(const FunctionExpanderConstRef function_expander, const bool single_root_function,
+   CallGraphManager(const FunctionExpanderConstRef function_expander,
                     const bool allow_recursive_functions, const tree_managerConstRef tree_manager,
                     const ParameterConstRef Param);