AST Construction

AST construction is a fundamental operation needed for building ROSE source-to-source translators.

Several levels of interfaces are available in ROSE for users to build AST from scratch. High-level interfaces are recommended whenever possible for their simplicity. Low-level interfaces can give users maximum freedom to manipulate details in AST trees.

This tutorial demonstrates how to create AST fragments for common language constructs (such as variable declarations, functions, function calls, etc.) and how to insert them into an existing AST tree.

Variable Declarations

Example 1: High-Level Variable Declaration

Building a variable declaration using the high-level AST construction and manipulation interfaces defined in the SageBuilder and SageInterface namespaces.

// SageBuilder contains all high level buildXXX() functions,
// such as buildVariableDeclaration(), buildLabelStatement() etc.
// SageInterface contains high level AST manipulation and utility functions,
// e.g. appendStatement(), lookupFunctionSymbolInParentScopes() etc.
#include "rose.h"
using namespace SageBuilder;
using namespace SageInterface;
 
class SimpleInstrumentation:public SgSimpleProcessing
{
public:
  void visit (SgNode * astNode);
};
 
void
SimpleInstrumentation::visit (SgNode * astNode)
{
  SgBasicBlock *block = isSgBasicBlock (astNode);
  if (block != NULL)
    {
      SgVariableDeclaration *variableDeclaration =
                buildVariableDeclaration ("newVariable", buildIntType ());
      prependStatement (variableDeclaration, block);
    }
}
 
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);
}

The high-level construction builds a variable declaration node using buildVariableDeclaration() and inserts it into the AST with prependStatement(). Scope pointers, symbol tables, and source file position information are handled transparently.

Example 2: Low-Level Variable Declaration

Building the variable declaration using low-level member functions of SAGE III node classes. The low-level approach requires manual handling of scope, parent pointers, and symbol tables.

// ROSE is a tool for building preprocessors, this file is an example preprocessor built with ROSE.
// Specifically it shows the design of a transformation to instrument source code, placing source code
// at the top and bottom of each basic block.
// Member functions of SAGE III AST node classes are directly used.
// So all details for Sg_File_Info, scope, parent, symbol tables have to be explicitly handled.
 
#include "rose.h"
 
class SimpleInstrumentation : public SgSimpleProcessing
   {
     public:
          void visit ( SgNode* astNode );
   };
 
void
SimpleInstrumentation::visit ( SgNode* astNode )
   {
     SgBasicBlock* block = isSgBasicBlock(astNode);
     if (block != NULL)
        {
       // Mark this as a transformation (required)
          Sg_File_Info* sourceLocation = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
          ROSE_ASSERT(sourceLocation != NULL);
 
          SgType* type = new SgTypeInt();
          ROSE_ASSERT(type != NULL);
 
          SgName name = "newVariable";
 
          SgVariableDeclaration* variableDeclaration = new SgVariableDeclaration(sourceLocation,name,type);
          ROSE_ASSERT(variableDeclaration != NULL);
 
          SgInitializedName* initializedName = *(variableDeclaration->get_variables().begin());
          initializedName->set_file_info(Sg_File_Info::generateDefaultFileInfoForTransformationNode());
 
       // DQ (6/18/2007): The unparser requires that the scope be set (for name qualification to work).
          initializedName->set_scope(block);
 
       // Liao (2/13/2008): AstTests requires this to be set
          variableDeclaration->set_firstNondefiningDeclaration(variableDeclaration);
 
          ROSE_ASSERT(block->get_statements().size() > 0);
 
          block->get_statements().insert(block->get_statements().begin(),variableDeclaration);
          variableDeclaration->set_parent(block);
 
       // Add a symbol to the sybol table for the new variable
          SgVariableSymbol* variableSymbol = new SgVariableSymbol(initializedName);
          block->insert_symbol(name,variableSymbol);
        }
   }
 
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);
   }
 

Adding Expressions

A translator using the high-level AST builder interface can be used to add an assignment statement before the last statement in a main() function.

// Expressions can be built using both bottomup (recommended ) and topdown orders.
// Bottomup: build operands first, operation later
// Topdown: build operation first, set operands later on.
 
#include "rose.h"
using namespace SageBuilder;
using namespace SageInterface;
 
int main (int argc, char *argv[])
{
  // Initialize and check compatibility. See Rose::initialize
  ROSE_INITIALIZE;
 
  SgProject *project = frontend (argc, argv);
  // go to the function body
  SgFunctionDeclaration* mainFunc= findMain(project);
 
  SgBasicBlock* body= mainFunc->get_definition()->get_body();
  pushScopeStack(body);
  
 // bottomup: build operands first, create expression later on
 //  double result = 2 * (1 - gama * gama);
  SgExpression * init_exp =  
            buildMultiplyOp(buildDoubleVal(2.0),
                 buildSubtractOp(buildDoubleVal(1.0), 
                      buildMultiplyOp (buildVarRefExp("gama"),buildVarRefExp("gama")
                                      )));
  SgVariableDeclaration* decl = buildVariableDeclaration("result",buildDoubleType(),buildAssignInitializer(init_exp));
 
  SgStatement* laststmt = getLastStatement(topScopeStack());
  insertStatementBefore(laststmt,decl);
 
 // topdown: build expression first, set operands later on
 // double result2 = alpha * beta;
  SgExpression * init_exp2 = buildMultiplyOp();
  setLhsOperand(init_exp2,buildVarRefExp("alpha"));
  setRhsOperand(init_exp2,buildVarRefExp("beta"));
 
  SgVariableDeclaration* decl2 = buildVariableDeclaration("result2",buildDoubleType(),buildAssignInitializer(init_exp2));
  laststmt = getLastStatement(topScopeStack());
  insertStatementBefore(laststmt,decl2);
 
  popScopeStack();
  AstTests::runAllTests(project);
 
  //invoke backend compiler to generate object/binary files
   return backend (project);
 
}
 

Assignment Statements

Adding an assignment statement before the last statement in a main() function using the high-level AST builder interface.

// SageBuilder contains all high level buildXXX() functions,
// such as buildVariableDeclaration(), buildLabelStatement() etc.
// SageInterface contains high level AST manipulation and utility functions,
// e.g. appendStatement(), lookupFunctionSymbolInParentScopes() etc.
#include "rose.h"
using namespace SageBuilder;
using namespace SageInterface;
 
int main (int argc, char *argv[])
{
  // Initialize and check compatibility. See Rose::initialize
  ROSE_INITIALIZE;
 
  SgProject *project = frontend (argc, argv);
 
  // go to the function body of main()
  // and push it to the scope stack
  SgFunctionDeclaration* mainFunc= findMain(project);
  SgBasicBlock* body= mainFunc->get_definition()->get_body();
  pushScopeStack(body);
 
  // build a variable assignment statement: i=9;
  // buildVarRefExp(string varName) will automatically search for a matching variable symbol starting 
  // from the current scope to the global scope.
  SgExprStatement* assignStmt = buildAssignStatement(buildVarRefExp("i"),buildIntVal(9));
 
 // insert it before the last return statement
  SgStatement* lastStmt = getLastStatement(topScopeStack());
  insertStatementBefore(lastStmt,assignStmt); 
 
  popScopeStack();
 
  //AstTests ensures there is no dangling SgVarRefExp without a mathing symbol
  AstTests::runAllTests(project);
  return backend (project);
}
 

Function Declarations

Adding a function at the top of a global scope using both high-level and low-level constructions.

High-Level Function Declaration

// 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);
   }

High-Level Function Declaration with Scope Stack

// This example shows how to construct a defining function (with a function body)
// using high level AST construction interfaces.
// A scope stack is used to pass scope information implicitly to some builder functions
#include "rose.h"
using namespace SageBuilder;
using namespace SageInterface;
 
int
main ( int argc, char * argv[] )
   {
 // Initialize and check compatibility. See Rose::initialize
     ROSE_INITIALIZE;
 
     SgProject* project = frontend(argc,argv);
     ROSE_ASSERT(project != NULL);
     SgGlobal *globalScope = getFirstGlobalScope (project);
 
 //push global scope into stack
     pushScopeStack (isSgScopeStatement (globalScope));
 
 // 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);
    SgBasicBlock*  func_body    = func->get_definition()->get_body();
 
 // push function body scope into stack
    pushScopeStack(isSgScopeStatement(func_body));
 
 // build a statement in the function body
    SgVarRefExp *var_ref = buildVarRefExp(var1_name);
    SgPlusPlusOp *pp_expression = buildPlusPlusOp(var_ref);
    SgExprStatement* new_stmt = buildExprStatement(pp_expression);
                     
 // insert a statement into the function body
    appendStatement(new_stmt);
//  pop function body off the stack
    popScopeStack();
    
//  insert the function declaration into the scope at the top of the scope stack    
    prependStatement(func);
    popScopeStack();
 
    AstTests::runAllTests(project);
    return backend(project);
 }

Low-Level Function Declaration

Function Calls

Adding function calls to instrument code using the AST string-based rewrite mechanism or the AST builder interface.

AST Builder Interface Example

// ROSE is a tool for building preprocessors, this file is an example preprocessor built with ROSE.
// Specifically it shows the design of a transformation to instrument source code, placing source code
// at the top and bottom of each basic block.
 
#include "rose.h"
using namespace std;
using namespace SageInterface;
using namespace SageBuilder;
 
class SimpleInstrumentation:public SgSimpleProcessing
{
public:
  void visit (SgNode * astNode);
};
 
void
SimpleInstrumentation::visit (SgNode * astNode)
{
  SgBasicBlock *block = isSgBasicBlock (astNode);
  if (block != NULL)
    {
      const unsigned int SIZE_OF_BLOCK = 1;
      if (block->get_statements ().size () > SIZE_OF_BLOCK)
        {
          SgName name1("myTimerFunctionStart");
          // It is up to the user to link the implementations of these functions link time
          SgFunctionDeclaration *decl_1 = buildNondefiningFunctionDeclaration
              (name1,buildVoidType(),buildFunctionParameterList(),block);
          ((decl_1->get_declarationModifier()).get_storageModifier()).setExtern();
 
          SgExprStatement* callStmt_1 = buildFunctionCallStmt
              (name1,buildVoidType(), buildExprListExp(),block);
          
          prependStatement(callStmt_1,block);
          prependStatement(decl_1,block);
 
          SgName name2("myTimerFunctionEnd");
          // It is up to the user to link the implementations of these functions link time
          SgFunctionDeclaration *decl_2 = buildNondefiningFunctionDeclaration
              (name2,buildVoidType(),buildFunctionParameterList(),block);
          ((decl_2->get_declarationModifier()).get_storageModifier()).setExtern();
 
          SgExprStatement* callStmt_2 = buildFunctionCallStmt
              (name2,buildVoidType(), buildExprListExp(),block);
 
          appendStatement(decl_2,block);
          appendStatement(callStmt_2,block);
        }
    }
}
 
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);
}

Creating a 'struct' for Global Variables

This tutorial demonstrates how to repackage global variables into a struct to support Charm++. The translator also updates all references to global variables so that they reference the variables indirectly through the struct. This is a preprocessing step required to use Charm++ and AMPI.

The example uses low-level AST manipulation at the level of the IR. More concise versions using SageInterface and SageBuilder functions should be considered for high-level manipulation.

Repackaging Global Variables

The following example repackages global variables in an application into a struct.

// ROSE is a tool for building preprocessors, this file is an example preprocessor built with ROSE.
// Specifically it shows the design of a transformation to do a transformation specific for Charm++.
 
#include "rose.h"
 
using namespace std;
 
Rose_STL_Container<SgInitializedName*>
buildListOfGlobalVariables ( SgSourceFile* file )
   {
  // This function builds a list of global variables (from a SgFile).
     assert(file != NULL);
 
     Rose_STL_Container<SgInitializedName*> globalVariableList;
 
     SgGlobal* globalScope = file->get_globalScope();
     assert(globalScope != NULL);
     Rose_STL_Container<SgDeclarationStatement*>::iterator i = globalScope->get_declarations().begin();
     while(i != globalScope->get_declarations().end())
        {
          SgVariableDeclaration *variableDeclaration = isSgVariableDeclaration(*i);
          if (variableDeclaration != NULL)
             {
               Rose_STL_Container<SgInitializedName*> & variableList = variableDeclaration->get_variables();
               Rose_STL_Container<SgInitializedName*>::iterator var = variableList.begin();
               while(var != variableList.end())
                  {
                    globalVariableList.push_back(*var);
                    var++;
                  }
             }
          i++;
        }
 
     return globalVariableList;
   }
 
// This function is not used, but is useful for 
// generating the list of all global variables
Rose_STL_Container<SgInitializedName*>
buildListOfGlobalVariables ( SgProject* project )
   {
  // This function builds a list of global variables (from a SgProject).
 
     Rose_STL_Container<SgInitializedName*> globalVariableList;
 
     const SgFilePtrList& fileList = project->get_fileList();
     SgFilePtrList::const_iterator file = fileList.begin();
 
  // Loop over the files in the project (multiple files exist 
  // when multiple source files are placed on the command line).
     while(file != fileList.end())
        {
          Rose_STL_Container<SgInitializedName*> fileGlobalVariableList = buildListOfGlobalVariables(isSgSourceFile(*file));
 
       // DQ (9/26/2007): Moved from std::list to std::vector
       // globalVariableList.merge(fileGlobalVariableList);
          globalVariableList.insert(globalVariableList.begin(),fileGlobalVariableList.begin(),fileGlobalVariableList.end());
 
          file++;
        }
 
     return globalVariableList;
   }
 
Rose_STL_Container<SgVarRefExp*>
buildListOfVariableReferenceExpressionsUsingGlobalVariables ( SgNode* node )
   {
  // This function builds a list of "uses" of variables (SgVarRefExp IR nodes) within the AST.
 
  // return variable
     Rose_STL_Container<SgVarRefExp*> globalVariableUseList;
 
  // list of all variables (then select out the global variables by testing the scope)
     Rose_STL_Container<SgNode*> nodeList = NodeQuery::querySubTree ( node, V_SgVarRefExp );
 
     Rose_STL_Container<SgNode*>::iterator i = nodeList.begin();
     while(i != nodeList.end())
        {
          SgVarRefExp *variableReferenceExpression = isSgVarRefExp(*i);

Referencing Global Variables via Struct (Part 2)

This part shows the continuation of the repackaging of global variables into a struct.

          assert(variableReferenceExpression != NULL);
 
          assert(variableReferenceExpression->get_symbol() != NULL);
          assert(variableReferenceExpression->get_symbol()->get_declaration() != NULL);
          assert(variableReferenceExpression->get_symbol()->get_declaration()->get_scope() != NULL);
 
       // Note that variableReferenceExpression->get_symbol()->get_declaration() returns the 
       // SgInitializedName (not the SgVariableDeclaration where it was declared)!
          SgInitializedName* variable = variableReferenceExpression->get_symbol()->get_declaration();
 
          SgScopeStatement* variableScope = variable->get_scope();
 
       // Check if this is a variable declared in global scope, if so, then save it
          if (isSgGlobal(variableScope) != NULL)
             {
               globalVariableUseList.push_back(variableReferenceExpression);
             }
          i++;
        }
 
     return globalVariableUseList;
   }
 
 
SgClassDeclaration*
buildClassDeclarationAndDefinition (string name, SgScopeStatement* scope)
   {
  // This function builds a class declaration and definition 
  // (both the defining and nondefining declarations as required).
 
  // Build a file info object marked as a transformation
     Sg_File_Info* fileInfo = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
     assert(fileInfo != NULL);
 
  // This is the class definition (the fileInfo is the position of the opening brace)
     SgClassDefinition* classDefinition   = new SgClassDefinition(fileInfo);
     assert(classDefinition != NULL);
 
  // Set the end of construct explictly (where not a transformation this is the location of the closing brace)
     classDefinition->set_endOfConstruct(fileInfo);
 
  // This is the defining declaration for the class (with a reference to the class definition)
     SgClassDeclaration* classDeclaration = new SgClassDeclaration(fileInfo,name.c_str(),SgClassDeclaration::e_struct,NULL,classDefinition);
     assert(classDeclaration != NULL);
 
  // Set the defining declaration in the defining declaration!
     classDeclaration->set_definingDeclaration(classDeclaration);
 
  // Set the non defining declaration in the defining declaration (both are required)
     SgClassDeclaration* nondefiningClassDeclaration = new SgClassDeclaration(fileInfo,name.c_str(),SgClassDeclaration::e_struct,NULL,NULL);
     assert(classDeclaration != NULL);
     nondefiningClassDeclaration->set_scope(scope);
     nondefiningClassDeclaration->set_type(SgClassType::createType(nondefiningClassDeclaration));
 
  // Set the internal reference to the non-defining declaration
     classDeclaration->set_firstNondefiningDeclaration(nondefiningClassDeclaration);
     classDeclaration->set_type(nondefiningClassDeclaration->get_type());
 
  // Set the defining and no-defining declarations in the non-defining class declaration!
     nondefiningClassDeclaration->set_firstNondefiningDeclaration(nondefiningClassDeclaration);
     nondefiningClassDeclaration->set_definingDeclaration(classDeclaration);
 
  // Set the nondefining declaration as a forward declaration!
     nondefiningClassDeclaration->setForward();
 
  // Don't forget the set the declaration in the definition (IR node constructors are side-effect free!)!
     classDefinition->set_declaration(classDeclaration);
 
  // set the scope explicitly (name qualification tricks can imply it is not always the parent IR node!)
     classDeclaration->set_scope(scope);
 
  // some error checking
     assert(classDeclaration->get_definingDeclaration() != NULL);
     assert(classDeclaration->get_firstNondefiningDeclaration() != NULL);
     assert(classDeclaration->get_definition() != NULL);
 
  // DQ (9/8/2007): Need to add function symbol to global scope!
     printf ("Fixing up the symbol table in scope = %p = %s for class = %p = %s \n",scope,scope->class_name().c_str(),classDeclaration,classDeclaration->get_name().str());
     SgClassSymbol* classSymbol = new SgClassSymbol(classDeclaration);
     scope->insert_symbol(classDeclaration->get_name(),classSymbol);

Handling Global Variables (Part 3)

The third part of the example, continuing the transformation of global variables into a struct.

     ROSE_ASSERT(scope->lookup_class_symbol(classDeclaration->get_name()) != NULL);
 
     return classDeclaration;
   }
 
 
 
SgVariableSymbol* 
putGlobalVariablesIntoClass (Rose_STL_Container<SgInitializedName*> & globalVariables, SgClassDeclaration* classDeclaration )
   {
  // This function iterates over the list of global variables and inserts them into the iput class definition
 
     SgVariableSymbol* globalClassVariableSymbol = NULL;
 
     for (Rose_STL_Container<SgInitializedName*>::iterator var = globalVariables.begin(); var != globalVariables.end(); var++)
        {
       // printf ("Appending global variable = %s to new globalVariableContainer \n",(*var)->get_name().str());
          SgVariableDeclaration* globalVariableDeclaration = isSgVariableDeclaration((*var)->get_parent());
          assert(globalVariableDeclaration != NULL);
 
       // Get the global scope from the global variable directly
          SgGlobal* globalScope = isSgGlobal(globalVariableDeclaration->get_scope());
          assert(globalScope != NULL);
 
          if (var == globalVariables.begin())
             {
            // This is the first time in this loop, replace the first global variable with 
            // the class declaration/definition containing all the global variables!
            // Note that initializers in the global variable declarations require modification 
            // of the preinitialization list in the class's constructor!  I am ignoring this for now!
               globalScope->replace_statement(globalVariableDeclaration,classDeclaration);
 
            // Build source position informaiton (marked as transformation)
               Sg_File_Info* fileInfo = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
               assert(fileInfo != NULL);
 
            // Add the variable of the class type to the global scope!
               SgClassType* variableType = new SgClassType(classDeclaration->get_firstNondefiningDeclaration());
               assert(variableType != NULL);
               SgVariableDeclaration* variableDeclaration = new SgVariableDeclaration(fileInfo,"AMPI_globals",variableType);
               assert(variableDeclaration != NULL);
 
               globalScope->insert_statement(classDeclaration,variableDeclaration,false);
 
               assert(variableDeclaration->get_variables().empty() == false);
               SgInitializedName* variableName = *(variableDeclaration->get_variables().begin());
               assert(variableName != NULL);
 
            // DQ (9/8/2007): Need to set the scope of the new variable.
               variableName->set_scope(globalScope);
 
            // build the return value
               globalClassVariableSymbol = new SgVariableSymbol(variableName);
 
            // DQ (9/8/2007): Need to add the symbol to the global scope (new testing requires this).
               globalScope->insert_symbol(variableName->get_name(),globalClassVariableSymbol);
               ROSE_ASSERT(globalScope->lookup_variable_symbol(variableName->get_name()) != NULL);
             }
            else
             {
            // for all other iterations of this loop ... 
            // remove variable declaration from the global scope
               globalScope->remove_statement(globalVariableDeclaration);
             }
 
       // add the variable declaration to the class definition
          classDeclaration->get_definition()->append_member(globalVariableDeclaration);
        }
 
     return globalClassVariableSymbol;
   }
 
 
void
fixupReferencesToGlobalVariables ( Rose_STL_Container<SgVarRefExp*> & variableReferenceList, SgVariableSymbol* globalClassVariableSymbol)
   {
  // Now fixup the SgVarRefExp to reference the global variables through a struct
     for (Rose_STL_Container<SgVarRefExp*>::iterator var = variableReferenceList.begin(); var != variableReferenceList.end(); var++)
        {
          assert(*var != NULL);

Final Steps of Global Variable Repackaging (Part 4)

This part completes the transformation and repackaging of global variables into a struct.

       // printf ("Variable reference for %s \n",(*var)->get_symbol()->get_declaration()->get_name().str());
 
          SgNode* parent = (*var)->get_parent();
          assert(parent != NULL);
 
       // If this is not an expression then is likely a meaningless statement such as ("x;")
          SgExpression* parentExpression = isSgExpression(parent);
          assert(parentExpression != NULL);
 
       // Build the reference through the global class variable ("x" --> "AMPI_globals.x")
 
       // Build source position informaiton (marked as transformation)
          Sg_File_Info* fileInfo = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
          assert(fileInfo != NULL);
 
       // Build "AMPI_globals"
          SgExpression* lhs = new SgVarRefExp(fileInfo,globalClassVariableSymbol);
          assert(lhs != NULL);
       // Build "AMPI_globals.x" from "x"
          SgDotExp* globalVariableReference = new SgDotExp(fileInfo,lhs,*var);
          assert(globalVariableReference != NULL);
 
          if (parentExpression != NULL)
             {
            // Introduce reference to *var through the data structure
 
            // case of binary operator
               SgUnaryOp* unaryOperator = isSgUnaryOp(parentExpression);
               if (unaryOperator != NULL)
                  {
                    unaryOperator->set_operand(globalVariableReference);
                  }
                 else
                  {
                 // case of binary operator
                    SgBinaryOp* binaryOperator = isSgBinaryOp(parentExpression);
                    if (binaryOperator != NULL)
                       {
                      // figure out if the *var is on the lhs or the rhs
                         if (binaryOperator->get_lhs_operand() == *var)
                            {
                              binaryOperator->set_lhs_operand(globalVariableReference);
                            }
                           else
                            {
                              assert(binaryOperator->get_rhs_operand() == *var);
                              binaryOperator->set_rhs_operand(globalVariableReference);
                            }
                       }
                      else
                       {
                      // ignore these cases for now!
                         switch(parentExpression->variantT())
                            {
                           // Where the variable appers in the function argument list the parent is a SgExprListExp
                              case V_SgExprListExp:
                                 {
                                   printf ("Sorry not implemented, case of global variable in function argument list ... \n");
                                   ROSE_ABORT();
                                 }
                              case V_SgInitializer:
                              case V_SgRefExp:
                              case V_SgVarArgOp:
                              default:
                                 {
                                   printf ("Error: default reached in switch  parentExpression = %p = %s \n",parentExpression,parentExpression->class_name().c_str());
                                   ROSE_ABORT();
                                 }
                            }
                       }
                  }
             }
        }
   }
 
#define OUTPUT_NAMES_OF_GLOBAL_VARIABLES           0
#define OUTPUT_NAMES_OF_GLOBAL_VARIABLE_REFERENCES 0
 
void
transformGlobalVariablesToUseStruct ( SgSourceFile *file )

Struct Usage Finalization (Part 5)

This is the final part of the global variable repackaging and struct manipulation process.

   {
     assert(file != NULL);
 
  // These are the global variables in the input program (provided as helpful information)
     Rose_STL_Container<SgInitializedName*> globalVariables = buildListOfGlobalVariables(file);
 
#if OUTPUT_NAMES_OF_GLOBAL_VARIABLES
     printf ("global variables (declared in global scope): \n");
     for (Rose_STL_Container<SgInitializedName*>::iterator var = globalVariables.begin(); var != globalVariables.end(); var++)
        {
          printf ("   %s \n",(*var)->get_name().str());
        }
     printf ("\n");
#endif
 
  // get the global scope within the first file (currently ignoring all other files)
     SgGlobal* globalScope = file->get_globalScope();
     assert(globalScope != NULL);
 
  // Build the class declaration
     SgClassDeclaration* classDeclaration = buildClassDeclarationAndDefinition("AMPI_globals_t",globalScope);
 
  // Put the global variables intothe class
     SgVariableSymbol* globalClassVariableSymbol = putGlobalVariablesIntoClass(globalVariables,classDeclaration);
 
  // Their associated symbols will be located within the project's AST 
  // (where they occur in variable reference expressions).
     Rose_STL_Container<SgVarRefExp*> variableReferenceList = buildListOfVariableReferenceExpressionsUsingGlobalVariables(file);
 
#if OUTPUT_NAMES_OF_GLOBAL_VARIABLE_REFERENCES
     printf ("global variables appearing in the application: \n");
     for (Rose_STL_Container<SgVarRefExp*>::iterator var = variableReferenceList.begin(); var != variableReferenceList.end(); var++)
        {
          printf ("   %s \n",(*var)->get_symbol()->get_declaration()->get_name().str());
        }
     printf ("\n");
#endif
 
  // Fixup all references to global variable to access the variable through the class ("x" --> "AMPI_globals.x")
     fixupReferencesToGlobalVariables(variableReferenceList,globalClassVariableSymbol);
   }
 
 
void
transformGlobalVariablesToUseStruct ( SgProject *project )
   {
  // Call the transformation of each file (there are multiple SgFile 
  // objects when multiple files are specfied on the command line!).
     assert(project != NULL);
 
     const SgFilePtrList& fileList = project->get_fileList();
     SgFilePtrList::const_iterator file = fileList.begin();
     while(file != fileList.end())
        {
          transformGlobalVariablesToUseStruct(isSgSourceFile(*file));
          file++;
        }
   }
 
// ******************************************
//              MAIN PROGRAM
// ******************************************
int
main( int argc, char * argv[] )
   {
  // Initialize and check compatibility. See Rose::initialize
     ROSE_INITIALIZE;
 
  // Build the AST used by ROSE
     SgProject* project = frontend(argc,argv);
     assert(project != NULL);
 
  // transform application as required
     transformGlobalVariablesToUseStruct(project);
 
  // Code generation phase (write out new application "rose_<input file name>")
     return backend(project);
   }

Example Input Code for Struct Repackaging

Example source code used as input to the translator for repackaging global variables into a struct.

int x;
int y;
long z;
float pressure;
 
int main()
   {
     int a = 0;
     int b = 0;
     float density = 1.0;
 
     x++;
     b++;
 
     x = a + y;
 
     return 0;
   }

Example Output of Global Variable Repackaging

The output of the input after the translator repackages the global variables into a struct.

 
struct AMPI_globals_t 
{
  int x;
  int y;
  long z;
  float pressure;
}
;
struct AMPI_globals_t AMPI_globals;
 
int main()
{
  int a = 0;
  int b = 0;
  float density = 1.0;
  AMPI_globals . x++;
  b++;
  AMPI_globals . x = a + AMPI_globals . y;
  return 0;
}