Re: Gimple Statement

[Nicolas BENOIT <nicolas dot benoit at cea dot fr>]

Hi,

I am not sure if that's the best way to do it, but here is how it could 
be achieved :

While browsing the Gimple statements
get the tree rhs1 with gimple_op(g,1)
the tree rhs2 with gimple_op(g,2) if gimple_num_ops(g) > 2
the tree lhs with gimple_op(g,0)

Then, explore recursively each tree according to the TREE_CODE.
Below is an example where a function fills a structure named 'operand'.
It uses a 'datacess' structure to describe the type of access (indirect, 
load address, array ref, etc.); operand and dataccess structures are 
nested, for example, for an array reference :

OPERAND
+ DATACCESS(ARRAY REF)
  + OPERAND(ARRAY)
    + DATACCESS(ARRAY DATA)
  + OPERAND(INDEX)
    + DATACCESS(INDEX DATA) or INTEGER CONSTANT

The root operand points to a dataccess of type ARRAY REF.
The ARRAY REF contains itself two operands, each linked to a dataccess.
This is build by recursively browsing the tree, use the print_node() 
function or the tree browser to understand how all this is arranged, and 
have a look at tree.h

You will need a structure to describe the data as well. Here, all the 
'data' structures build are added to a global database (DATA_DB).

Note that 'operand', 'dataccess', 'data' and 'datadb' are not part of 
GCC, this is just an illustration of a tree abstraction.
According to your goal, you may not need all of this.


operand
operand_new_from_tree ( tree optree )
{
  operand o;
  enum tree_code tc;

  tc = TREE_CODE ( optree );

  if ( tc == SSA_NAME )
    {
      o = operand_new_from_tree ( SSA_NAME_VAR(optree) );
      o->ssa = optree;
      return o;
    }
  else if ( ( tc == VAR_DECL ) || ( tc == PARM_DECL ) ||
            ( tc == FUNCTION_DECL ) || ( tc == CONST_DECL ) )
    {
      data d = datadb_find_with_tuid ( DATA_DB, DECL_UID(optree) );
      if ( d == NULL )
        d = data_new_from_tree ( optree );
      o = operand_new_with_data ( d );
    }
  else if ( tc == INTEGER_CST )
    {
      o = operand_new_with_integer_value ( TREE_INT_CST_LOW(optree) );
    }
  else if ( tc == REAL_CST )
    {
      o = operand_new_with_real_value ( &TREE_REAL_CST(optree) );
    }
#if BUILDING_GCC_MINOR>5
  else if ( tc == MEM_REF )
    {
      /* operand 0 is the pointer, operand 1 is the offset */
      o = operand_new_with_dataccess ( 
dataccess_new_indirect_ref_from_tree(TREE_OPERAND(optree,0)) );
      o->da->offset = TREE_INT_CST_LOW ( TREE_OPERAND(optree,1) );
    }
#endif
  else if ( tc == ARRAY_REF )
    {
      /* operand 0 is the array, operand 1 is the index */
      o = operand_new_with_dataccess ( 
dataccess_new_array_ref_from_trees(TREE_OPERAND(optree,0),TREE_OPERAND(optree,1)) 
);
    }
  else if ( tc == ADDR_EXPR )
    {
      o = operand_new_with_dataccess ( 
dataccess_new_address_load_from_tree(TREE_OPERAND(optree,0)) );
    }
  else if ( tc == INDIRECT_REF )
    {
      /* operand 0 is the pointer being dereferenced */
      o = operand_new_with_dataccess ( 
dataccess_new_indirect_ref_from_tree(TREE_OPERAND(optree,0)) );
    }
  else
    {
      fprintf ( stderr, "operand_new_from_tree(): unhandled \'%s\'\n", 
tree_code_name[TREE_CODE(optree)] );
      print_node ( stderr, "", optree, 0 );
      fprintf ( stderr, "\n" );
      gcc_unreachable ( );
      return NULL;
    }

  return o;
}


Regards,
Nicolas.


On 09/26/2010 07:46 AM, Mradul Maheshwari wrote:
> > "Mradul Maheshwari"<mradul@cse.iitb.ac.in>  writes:
> >
> > > I am trying to deduce the original statement from the set of gimple
> > > statements. For eg.
> > > These statement are in gimple
> > >
> > > x.0_1 = x;
> > >
> > > a.1_2 = (int)&a;
> > >
> > > *x.0_1 = a.1_2;
> > >
> > > their equivalent statement in c in *x =&a;
> > >
> > > how can I deduce this statement from these gimple statement?
> >
> > In what sense do you want to deduce the statement?  If you want to
> > deduce precisely "*x =&a", you can't.  GIMPLE does not preserve all the
> > information which is in the source code.  There could have been
> > temporary variables which have been discarded, or this assignment could
> > be part of a conditional or other statement, etc.  But you can see
> > pretty clearly that the effect of the three GIMPLE statements you list
> > above is indeed *x =&a.
> >
> > Ian
> I want to deduce that the effect of these 3 statement is - that in the lhs
> we are having x with 1 DEREFERENCING involved and the rhs is 'a' with
> ADDRESOF involved. I want to store this information in some data structure
> and then print it in a file.
> This information precisely means that
> -----lhs = x, dereferencing = 1, addressof = 0-----
> -----rhs = a, dereferencing = 0, addressof = 1-----
>
> I am trying to use some macros SSA_NAME_DEF_STMT and
> SSA_NAME_IMM_USE_NODE. But still not able to figure out how to use them.
>
> Mradul Maheshwari