rose

48 |   checkAndPatchUpOptions();
49 | 
50 |   // insert a header to support outlining for auto tuning
51 |   if (use_dlopen)
52 |   {
53 |     const string file_name = s->get_file_info()->get_filename();

433 |   ROSE_ASSERT(func->get_definition()->get_body()->get_parent() == func->get_definition());
434 | 
435 | #if 0
436 |   printf ("In outlineBlock(): use_dlopen = %s \n",use_dlopen ? "true" : "false");
437 | #endif
438 | 
439 |   SgStatement *func_call = NULL;
440 |   SgVarRefExp* wrapper_exp = NULL; 
441 |   if (use_dlopen) 
442 |     // if dlopen() is used, insert a lib call to find the function pointer from a shared lib file
443 |     // e.g. OUT__2__8072__p = findFunctionUsingDlopen("OUT__2__8072__", "OUT__2__8072__.so");
460 | //e.g.
461 | // OUT_1_test_26_2020_0p = findFunctionUsingDlopen("OUT_1_test_26_2020_0","test_26_2020/rose_test_26_2020_lib.so");  
462 |     SgExprListExp* arg_list = buildExprListExp(buildStringVal(func_name_str), buildStringVal(lib_name)); 
463 |     SgFunctionCallExp* dlopen_call = buildFunctionCallExp(SgName(FIND_FUNCP_DLOPEN),ftype_return,arg_list, p_scope);
464 |     SgExprStatement * assign_stmt = buildAssignStatement(buildVarRefExp(func_name_str+"p",p_scope),dlopen_call);
465 |     SageInterface::insertStatementBefore(s, assign_stmt);
466 |     // Generate a function call using the func pointer
488 |   else  // regular function call for other cases
489 |     {
490 | #if 0
491 |       printf ("use_dlopen == false: calling generateCall() \n");
492 | #endif
493 |       func_call = generateCall (func, syms, readOnlyVars, wrapper_name,p_scope);
494 | #if 0
495 |       printf ("DONE: use_dlopen == false: calling generateCall() \n");
496 | #endif
497 |     }

1098 |         ptype = buildPointerType (buildVoidType());
1099 |       }
1100 |       else // use array of pointers, regardless of the pass-by-value vs. pass-by-reference difference
1101 |       {     // this is to be compatible with dlopen() runtime's function pointer type
1102 |         ptype= buildPointerType(buildPointerType(buildVoidType()));
1103 |       }

69 |   ROSE_DLL_API extern bool enable_debug; // output debug information for outliner
70 |   ROSE_DLL_API extern bool exclude_headers; // exclude headers from the new file containing outlined functions
71 |   ROSE_DLL_API extern bool enable_liveness; // enable liveness analysis to reduce restoring statements when temp variables are used
72 |   ROSE_DLL_API extern bool use_dlopen; // Outlining the target to a separated file and calling it using a dlopen() scheme. It turns on useNewFile.
73 | 
74 |   ROSE_DLL_API extern bool enable_template;  // Enabling outlining code blocks inside template functions

39 |   bool enable_debug=true; // 
40 | #endif
41 |   bool exclude_headers=false;
42 |   bool use_dlopen=false; // Outlining the target to a separated file and calling it using a dlopen() scheme. It turns on useNewFile.
43 |   bool enable_template=false; // Outlining code blocks inside C++ templates
44 |   bool select_omp_loop = false;  // Find OpenMP for loops and outline them. This is used for testing purposes.
73 | {
74 |   // Generate a prefix.
75 |   stringstream s;
76 |   if (use_dlopen)  
77 |     s<< g_outlined_func_names2.next();
78 |   else
82 |   // tag.
83 |   const Sg_File_Info* info = stmt->get_startOfConstruct ();
84 |   ROSE_ASSERT (info);
85 |   if (use_dlopen)
86 |   {
87 |     const string file_name = info->get_raw_filename ();
235 |                     .intrinsicValue(true, temp_variable)
236 |                     .doc("Enable using temp variables to reduce pointer dereferencing for outlined functions."));
237 | 
238 |     switches.insert(Switch("use_dlopen")
239 |                     .intrinsicValue(true, use_dlopen)
240 |                     .doc("Use @man{dlopen}(3) to find an outlined function saved into a new source file."));
241 | 
242 |     switches.insert(Switch("enable_template")
301 |         useParameterWrapper = true;
302 |     }
303 |     //    use_dlopen = false;
304 |     if (use_dlopen) {
305 |         // turn on useNewFile as a side effect
306 |         useNewFile= true;
404 |   //  else
405 |   //    temp_variable = false;
406 |  
407 |   if (CommandlineProcessing::isOption (argvList,"-rose:outline:","use_dlopen",true))
408 |   {
409 |     if (enable_debug)
410 |       cout<<"Using dlopen() to find an outilned function saved into a new source file ..."<<endl;
411 |     use_dlopen = true;
412 |   }
413 |   //  else   // this option may be set by other module
439 |     argvList.push_back("-rose:openmp:ast_only");
440 |   }
441 |  
442 |  if (use_dlopen || temp_variable)    
443 |   {
444 |     if (CommandlineProcessing::isOption (argvList,"-rose:outline:","enable_liveness",true))
464 |     cout<<"\t-rose:outline:new_file                         use a new source file for the generated outlined function"<<endl;
465 |     cout<<"\t-rose:outline:output_path                      the path to store newly generated files for outlined functions, if requested by new_file. The original source file's path is used by default."<<endl;
466 |     cout<<"\t-rose:outline:exclude_headers                  do not include any headers in the new file for outlined functions"<<endl;
467 |     cout<<"\t-rose:outline:use_dlopen                       use dlopen() to find the outlined functions saved in new files.It will turn on new_file and parameter_wrapper flags internally"<<endl;
468 |     cout<<"\t-rose:outline:copy_orig_file                   used with dlopen(): single lib source file copied from the entire original input file. All generated outlined functions are appended to the lib source file"<<endl;
469 |     cout<<"\t-rose:outline:enable_template                  support outlining code blocks inside C++ templates (experimental)"<<endl;
470 |     cout<<"\t-rose:outline:enable_debug                     run outliner in a debugging mode"<<endl;

1519 |    SgFunctionDeclaration* sourceFileFunctionPrototype = NULL;
1520 | 
1521 | #if 0
1522 |    printf ("$$$$$$$$$$$$$$$ In Outliner::insert(): use_dlopen = %s \n",use_dlopen == true ? "true" : "false");
1523 | #endif
1524 | 
1525 |    // insert a pointer to function declaration if use_dlopen is true
1526 |    // insert it into the original global scope
1527 |    if (use_dlopen) 
1528 |    {
1529 |     // void (*OUT_xxx__p) (void**); // this parameter type depends on the number of variables. If zero variables, empty parameter.
1541 |      SgVariableDeclaration * ptofunc = buildVariableDeclaration(var_name,buildPointerType(ftype), NULL, target_outlined_code->get_scope());
1542 | 
1543 | #if 0
1544 |      printf ("############ In Outliner::insert(): use_dlopen == true: Calling SageInterface::insertStatementBefore: func = %p name = %s src_global = %p friendFunctionPrototypeList.size() = %zu \n",
1545 |           func,func->get_name().str(),src_global,friendFunctionPrototypeList.size());
1546 |         {
1559 | //   We still generate the prototype even they are not needed if dlopen() is used. 
1560 | //   since SageInterface::appendStatementWithDependentDeclaration() depends on it
1561 | // if (SageInterface::is_Fortran_language() == false ) // C/C++ only
1562 |    if (use_dlopen == false && SageInterface::is_Fortran_language() == false ) // C/C++ only
1563 |    {
1564 |      // This is done in the original file (does not effect the separate file if we outline the function there)
1567 |      // insertGlobalPrototype (func, protos, src_global, target_func);
1568 | 
1569 | #if 0
1570 |      printf ("############ Calling insertGlobalPrototype(): use_dlopen == false: func = %p name = %s src_global = %p friendFunctionPrototypeList.size() = %zu \n",
1571 |           func,func->get_name().str(),src_global,friendFunctionPrototypeList.size());
1572 | #endif

140 |       std::cout <<"  exclude_headers     = " <<Outliner::exclude_headers <<"\n";
141 |       std::cout <<"  enable_classic      = " <<Outliner::enable_classic <<"\n";
142 |       std::cout <<"  temp_variable       = " <<Outliner::temp_variable <<"\n";
143 |       std::cout <<"  use_dlopen          = " <<Outliner::use_dlopen <<"\n";
144 |       std::cout <<"  handles             = [";
145 |       BOOST_FOREACH (const std::string &handle, Outliner::handles)