1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// This example shows how to construct a defining function (with a function body)
// using high level AST construction interfaces.
//
#include "rose.h"
using namespace SageBuilder;
using namespace SageInterface;

class SimpleInstrumentation : public SgSimpleProcessing
   {
     public:
          void visit ( SgNode* astNode );
   };

void
SimpleInstrumentation::visit ( SgNode* astNode )
   {
     SgGlobal* globalScope = isSgGlobal(astNode);
     if (globalScope != NULL)
        {
       // ********************************************************************
       // Create a parameter list with a parameter
       // ********************************************************************
          SgName var1_name = "var_name";
          SgReferenceType *ref_type = buildReferenceType(buildIntType());
          SgInitializedName *var1_init_name = buildInitializedName(var1_name, ref_type);
          SgFunctionParameterList* parameterList = buildFunctionParameterList();
          appendArg(parameterList,var1_init_name);

       // *****************************************************
       // Create a defining functionDeclaration (with a function body)
       // *****************************************************
          SgName func_name                    = "my_function";
          SgFunctionDeclaration * func        = buildDefiningFunctionDeclaration
                        (func_name, buildIntType(), parameterList,globalScope);
          SgBasicBlock*  func_body    = func->get_definition()->get_body();

       // ********************************************************
       // Insert a statement in the function body
       // *******************************************************

          SgVarRefExp *var_ref = buildVarRefExp(var1_name,func_body);
          SgPlusPlusOp *pp_expression = buildPlusPlusOp(var_ref);
          SgExprStatement* new_stmt = buildExprStatement(pp_expression);

       // insert a statement into the function body
          prependStatement(new_stmt,func_body);
          prependStatement(func,globalScope);

        }
   }

int
main ( int argc, char * argv[] )
   {
  // Initialize and check compatibility. See Rose::initialize
     ROSE_INITIALIZE;

     SgProject* project = frontend(argc,argv);
     ROSE_ASSERT(project != NULL);

     SimpleInstrumentation treeTraversal;
     treeTraversal.traverseInputFiles ( project, preorder );

     AstTests::runAllTests(project);
     return backend(project);
   }

1
2
3
4
5
6
7
8
9
10
11
12
int my_function(int &var_name)
{
  ++var_name;
}

int main()
{
  for (int i = 0; i < 4; i++) {
    int x;
  }
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*! \brief  test SageBuilder::buildFunctionCallStmt()
*   It can
*   - build a function call statement when the function is already declared.
*   - build a function call statement without previous declaration, a header is inserted first
*/
#include "rose.h"
#include <iostream>
using namespace std;
using namespace SageInterface;
using namespace SageBuilder;

int main (int argc, char *argv[])
{
  SgProject *project = frontend (argc, argv);

  //MiddleLevelRewrite::insert() is not stable
  // we only deal with one file here, so only one global scope
  SgGlobal* globalscope = getFirstGlobalScope(project);
  // insert header
#if 0
 // using MiddleLevelRewrite to parse the content of the header, but NOT working!
  MiddleLevelRewrite::ScopeIdentifierEnum scope = MidLevelCollectionTypedefs::StatementScope;
  MiddleLevelRewrite::PlacementPositionEnum locationInScope = \
        MidLevelCollectionTypedefs::TopOfCurrentScope;
  MiddleLevelRewrite::insert(globalscope,"#include \"inputbuildFunctionCalls.h\" \n",scope,locationInScope);
#else

  insertHeader("inputbuildFunctionCalls.h",PreprocessingInfo::after,false,globalscope);
#endif
  // go to the function body
  SgFunctionDeclaration* mainFunc= findMain(project);
  SgBasicBlock* body= mainFunc->get_definition()->get_body();
  pushScopeStack(body);

  // void foo(int p_sum)
  SgType* return_type = buildVoidType();
  SgVarRefExp* arg1 = buildVarRefExp(SgName("p_sum"));//type is inferred from symbol table
  SgExprListExp* arg_list = buildExprListExp();
  appendExpression(arg_list,arg1);
  SgExprStatement* callStmt1 = buildFunctionCallStmt(SgName("foo"),return_type, arg_list);

      // insert before the last return statement
  SgStatement* lastStmt = getLastStatement(topScopeStack());
  insertStatement(lastStmt,callStmt1);
#if 1
  //int bar(double); it is declared in a header
  //build call stmt then
  SgType* return_type_2 = buildIntType();
  SgDoubleVal* arg_2 = buildDoubleVal(0.5);
  SgExprListExp* arg_list_2 = buildExprListExp();
  appendExpression(arg_list_2,arg_2);
  SgExprStatement* callStmt_2 = buildFunctionCallStmt(SgName("bar"),return_type_2, arg_list_2);

      // insert before the last return statement
  lastStmt = getLastStatement(topScopeStack());
  insertStatement(lastStmt,callStmt_2);
#endif
  popScopeStack();
  AstPostProcessing(project);

  AstTests::runAllTests(project);

  return backend (project);
}

1
2
3
4
5
6
7
8
9
10
#include "inputbuildFunctionCalls.h"
void foo(int x);

int main()
{
  int p_sum = 0;
  foo(p_sum);
  bar(0.500000);
  return p_sum;
}