gcc/python/py-stmt-pass-mangr.c

   1 /* This file is part of GCC.
   2
   3 GCC is free software; you can redistribute it and/or modify it under
   4 the terms of the GNU General Public License as published by the Free
   5 Software Foundation; either version 3, or (at your option) any later
   6 version.
   7
   8 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
   9 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11 for more details.
  12
  13 You should have received a copy of the GNU General Public License
  14 along with GCC; see the file COPYING3.  If not see
  15 <http://www.gnu.org/licenses/>.  */
  16
  17 #include "config.h"
  18 #include "system.h"
  19 #include "ansidecl.h"
  20 #include "coretypes.h"
  21 #include "tm.h"
  22 #include "opts.h"
  23 #include "tree.h"
  24 #include "tree-iterator.h"
  25 #include "tree-pass.h"
  26 #include "gimple.h"
  27 #include "toplev.h"
  28 #include "debug.h"
  29 #include "options.h"
  30 #include "flags.h"
  31 #include "convert.h"
  32 #include "diagnostic-core.h"
  33 #include "langhooks.h"
  34 #include "langhooks-def.h"
  35 #include "target.h"
  36 #include "cgraph.h"
  37
  38 #include <gmp.h>
  39 #include <mpfr.h>
  40
  41 #include "vec.h"
  42 #include "hashtab.h"
  43
  44 #include "gpython.h"
  45 #include "py-dot.h"
  46 #include "py-vec.h"
  47 #include "py-tree.h"
  48
  49 static VEC(gpydot,gc) * gpy_decls;
  50
  51 typedef VEC(gpydot,gc) * (*DOT_stmt_pass__)(VEC(gpydot,gc) *);
  52 static DOT_stmt_pass__ gpy_stmt_pass_mngr[] =
  53 {
  54   NULL /* sentinal */
  55 };
  56
  57 /* Pushes each decl from the parser onto the current translation unit */
  58 void gpy_stmt_process_decl (gpy_dot_tree_t * const dot)
  59 {
  60   /* Push the declaration! */
  61   VEC_safe_push (gpydot, gc, gpy_decls, dot);
  62   debug ("decl <%p> was pushed!\n", (void*)dot);
  63 }
  64
  65 /**
  66  * Fairly Confusing Function to read.
  67  *
  68  * example:
  69  *    >>> x = y = z = 2 + 2 + 2;
  70  *
  71  *    --- Currently Yacc parses that expression into this Tree, which is just
  72           side effect of the way we generate the gpy_dot_tree's the much higher level IR
  73           which we bring down to GENERIC:
  74
  75                       +
  76                      / \
  77                     +   2
  78                    /
  79                   =
  80                  / \
  81                 x   =
  82                    / \
  83                   y   =
  84                      / \
  85                     z   2
  86
  87   -- Is converted into the procedure:
  88
  89   1. z = 2 + 2 + 2;
  90   2. y = z;
  91   3. x = y;
  92
  93   -- Tree structure as so:
  94
  95                  =
  96                 / \
  97                x   =
  98                   / \
  99                  y   =
 100                     / \
 101                    z   +
 102                       / \
 103                      +   2
 104                     / \
 105                    2   2
 106  **/
 107 gpy_dot_tree_t * gpy_stmt_process_AST_Align (gpy_dot_tree_t ** d_dot)
 108 {
 109   gpy_dot_tree_t * retval = NULL_DOT;
 110   gpy_dot_tree_t * nn = NULL_DOT;
 111   gpy_dot_tree_t * dot = *d_dot;
 112
 113   if (DOT_CHAIN(dot))
 114     {
 115       nn = DOT_CHAIN(dot);
 116       DOT_CHAIN(dot) = NULL_DOT;
 117     }
 118   retval = (*d_dot);
 119
 120   if (DOT_TYPE(retval) != D_MODIFY_EXPR)
 121     {
 122       gpy_dot_tree_t *o = retval;
 123       gpy_dot_tree_t *h = NULL_DOT;
 124
 125       while (o != NULL_DOT)
 126         {
 127           if ((DOT_TYPE(o) != D_IDENTIFIER) ||
 128               (DOT_TYPE(o) != D_PRIMITIVE))
 129             {
 130               if (DOT_lhs_T(o) == D_TD_DOT)
 131                 {
 132                   if (DOT_TYPE(DOT_lhs_TT(o)) == D_MODIFY_EXPR)
 133                     {
 134                       h = o;
 135                       break;
 136                     }
 137                   else
 138                     {
 139                       o = DOT_lhs_TT(o);
 140                     }
 141                 }
 142               else break;
 143             }
 144           else break;
 145         }
 146       if (h)
 147         {
 148           gpy_dot_tree_t  *head = DOT_lhs_TT(h);
 149           if (DOT_TYPE(DOT_rhs_TT(head)) == D_MODIFY_EXPR)
 150             {
 151               gpy_dot_tree_t  *t = head, *m = NULL_DOT;
 152               while (t)
 153                 {
 154                   if ((DOT_TYPE(t) != D_IDENTIFIER) ||
 155                       (DOT_TYPE(t) != D_PRIMITIVE))
 156                     {
 157                       if (DOT_TYPE(DOT_rhs_TT(t)) != D_MODIFY_EXPR)
 158                         {
 159                           m = t;
 160                           break;
 161                         }
 162                       else
 163                         {
 164                           t = t->opb.t;
 165                         }
 166                     }
 167                   else break;
 168                 }
 169
 170               if( m )
 171                 {
 172                   DOT_lhs_TT(h) = DOT_rhs_TT(m);
 173                   DOT_rhs_TT(m) = retval;
 174                 }
 175               else
 176                 fatal_error ("error processing the expression AST!\n");
 177             }
 178           else
 179             {
 180               DOT_lhs_TT(h) = DOT_rhs_TT(head);
 181               DOT_rhs_TT(head) = retval;
 182             }
 183           retval = head;
 184         }
 185     }
 186
 187   if (nn)
 188     DOT_CHAIN(retval) = nn;
 189   (*d_dot) = retval;
 190
 191   return retval;
 192 }
 193
 194 /**
 195  * Things are quite complicated from here on and will change frequently
 196  * We need to do a 1st pass over the code to generate our module.
 197
 198  Example:
 199
 200  x = 1
 201  y = 2
 202  def foo ():
 203    return x + y
 204  print foo ()
 205
 206  we need to generate out RECORD_TYPE with FIELDS x,y then pass again to generate
 207  the rest of the code as our first pass will let us generate our TYPE so we know
 208  how to access each variable in each context on the 2nd pass.
 209
 210  struct main.main {
 211   gpy_object_t *x , *y;
 212  }
 213
 214  gpy_object_t * main.foo (struct main.main * self, gpy_object_t ** __args)
 215  {
 216    T.1 = gpy_rr_bin_op (OP_ADDITION, self->x, self->y);
 217    return T.1;
 218  }
 219
 220  void main.init (struct main.main *self)
 221  {
 222    self->x = fold_int (1);
 223    self->y = fold_int (2);
 224
 225    T.2 = fold_call (&main.foo, 1, self)
 226    gpy_rr_print_stmt (1, T.2)
 227  }
 228
 229  int main (int argc, char *argv[])
 230  {
 231    int retval;
 232
 233    init_runtime ();
 234
 235    struct main.main P;
 236    main.init (&P);
 237
 238    cleanup_runtime ();
 239
 240    retval = 0;
 241    return retval;
 242  }
 243
 244  **/
 245 void gpy_stmt_write_globals (void)
 246 {
 247   int idx = 0;
 248   VEC(gpydot,gc) * dot_decls = gpy_decls;
 249   while (gpy_stmt_pass_mngr[idx] != NULL)
 250     {
 251       DOT_stmt_pass__ x = gpy_stmt_pass_mngr[idx];
 252       dot_decls = x(dot_decls);
 253       idx++;
 254     }
 255
 256   VEC(tree,gc) * module_types = gpy_stmt_pass_generate_types (dot_decls);
 257   VEC(tree,gc) * dot2gen_trees = gpy_stmt_pass_lower (module_types, gpy_decls);
 258   VEC(tree,gc) * globals = dot2gen_trees;
 259
 260   int global_vec_len = VEC_length (tree, globals);
 261   tree * global_vec = XNEWVEC (tree, global_vec_len);
 262   tree itx = NULL_TREE;
 263   int idy = 0;
 264
 265   FILE *tu_stream = dump_begin (TDI_tu, NULL);
 266   for (idx=0; VEC_iterate (tree,globals,idx,itx); ++idx)
 267     {
 268       debug_tree (itx);
 269
 270       if (tu_stream)
 271         dump_node (itx, 0, tu_stream);
 272
 273       global_vec [idy] = itx;
 274       idy++;
 275     }
 276   if (tu_stream)
 277     dump_end(TDI_tu, tu_stream);
 278
 279   debug("Finished processing!\n\n");
 280
 281   debug("global_vec len = <%i>!\n", global_vec_len);
 282
 283   wrapup_global_declarations (global_vec, global_vec_len);
 284
 285   check_global_declarations (global_vec, global_vec_len);
 286   emit_debug_global_declarations (global_vec, global_vec_len);
 287
 288   cgraph_finalize_compilation_unit ();
 289
 290   debug("finished passing to middle-end!\n\n");
 291 }