gcc/python/py-stmt.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-codes.def"
  46 #include "py-dot.h"
  47 #include "py-vec.h"
  48 #include "py-tree.h"
  49 #include "py-types.h"
  50 #include "py-runtime.h"
  51
  52 static gpy_symbol_obj * gpy_process_AST_Align( gpy_symbol_obj ** );
  53
  54 static VEC( gpy_sym,gc ) * gpy_decls;
  55 VEC(gpy_ctx_t,gc) * gpy_ctx_table;
  56 VEC(tree,gc) * global_decls;
  57 VEC(tree,gc) * gpy_toplev_fncs;
  58
  59 void gpy_process_decl( gpy_symbol_obj * sym )
  60 {
  61   /* Push the declaration! */
  62   VEC_safe_push( gpy_sym, gc, gpy_decls, sym );
  63   debug("decl <%p> was pushed!\n", (void*)sym );
  64 }
  65
  66 /**
  67  * Fairly Confusing Function to read.
  68  *
  69  * example:
  70  *    >>> x = y = z = 2 + 2 + 2;
  71  *
  72  *    --- Currently Yacc parses that expression into this Tree:
  73
  74                       +
  75                      / \
  76                     +   2
  77                    /
  78                   =
  79                  / \
  80                 x   =
  81                    / \
  82                   y   =
  83                      / \
  84                     z   2
  85
  86   -- Is converted into the procedure:
  87
  88   1. z = 2 + 2 + 2;
  89   2. y = z;
  90   3. x = y;
  91
  92   -- Tree structure as so:
  93
  94                  =
  95                 / \
  96                x   =
  97                   / \
  98                  y   =
  99                     / \
 100                    z   +
 101                       / \
 102                      +   2
 103                     / \
 104                    2   2
 105  **/
 106 static
 107 gpy_symbol_obj * gpy_process_AST_Align( gpy_symbol_obj ** sym )
 108 {
 109   gpy_symbol_obj *nn = NULL;
 110   gpy_symbol_obj *retval = NULL;
 111   if( (*sym)->next )
 112     {
 113       nn = (*sym)->next;
 114       (*sym)->next = NULL;
 115     }
 116   retval = (*sym);
 117
 118   if( (*sym)->exp == OP_EXPRESS )
 119     {
 120       debug("Processing Expression AST!\n");
 121       if( retval->type != OP_ASSIGN_EVAL )
 122         {
 123           gpy_symbol_obj *o= retval;
 124           gpy_symbol_obj *h= NULL;
 125           while( o )
 126             {
 127               if( o->op_a_t == TYPE_SYMBOL )
 128                 {
 129                   if( o->op_a.symbol_table->type == OP_ASSIGN_EVAL )
 130                     {
 131                       h = o;
 132                       break;
 133                     }
 134                   else
 135                     {
 136                       o = o->op_a.symbol_table;
 137                     }
 138                 }
 139               else break;
 140             }
 141           if( h )
 142             {
 143               gpy_symbol_obj *head = h->op_a.symbol_table;
 144               if( head->op_b.symbol_table->type == OP_ASSIGN_EVAL )
 145                 {
 146                   gpy_symbol_obj *t = head, *m = NULL;
 147                   while( t )
 148                     {
 149                       if( t->op_b_t == TYPE_SYMBOL )
 150                         {
 151                           if( t->op_b.symbol_table->type != OP_ASSIGN_EVAL )
 152                             {
 153                               m = t;
 154                               break;
 155                             }
 156                           else
 157                             {
 158                               t = t->op_b.symbol_table;
 159                             }
 160                         }
 161                       else break;
 162                     }
 163                   if( m )
 164                     {
 165                       h->op_a.symbol_table = m->op_b.symbol_table;
 166                       m->op_b.symbol_table = retval;
 167                     }
 168                   else
 169                     {
 170                       fatal_error("error processing the expression AST!\n");
 171                     }
 172                 }
 173               else
 174                 {
 175                   h->op_a.symbol_table = head->op_b.symbol_table;
 176                   head->op_b.symbol_table = retval;
 177                 }
 178               retval = head;
 179             }
 180         }
 181     }
 182
 183   if( nn )
 184     {
 185       retval->next = nn;
 186     }
 187   (*sym) = retval;
 188
 189   return retval;
 190 }
 191
 192 VEC(tree,gc) * gpy_process_expression( const gpy_symbol_obj * const sym,
 193                                        VEC(gpy_ctx_t,gc) * context )
 194 {
 195   VEC(tree,gc) * retval = NULL;
 196   if( sym->type == SYMBOL_PRIMARY )
 197     {
 198       retval = VEC_alloc(tree,gc,0);
 199       VEC(tree,gc) *primitive = gpy_fold_primitive( sym );
 200       gcc_assert( VEC_length(tree,primitive) == 1 );
 201       VEC_safe_push( tree,gc,retval,VEC_index(tree,primitive,0) );
 202     }
 203   else if( sym->type == SYMBOL_REFERENCE )
 204     {
 205       gcc_assert( sym->op_a_t == TYPE_STRING );
 206       tree decl = gpy_ctx_lookup_decl( context, sym->op_a.string, VAR );
 207       if( decl )
 208         {
 209           retval = VEC_alloc(tree,gc,0);
 210           debug("tree reference <%s>!\n", sym->op_a.string);
 211           VEC_safe_push( tree,gc,retval,decl );
 212         }
 213       else
 214         {
 215           error("undeclared symbol reference <%s>!\n",
 216                 sym->op_a.string );
 217         }
 218     }
 219   else
 220     {
 221       gpy_symbol_obj *opa= NULL, *opb= NULL; VEC(tree,gc) *res = NULL;
 222       debug("expression evalution <0x%x>!\n", sym->type );
 223
 224       opa= sym->op_a.symbol_table;
 225       opb= sym->op_b.symbol_table;
 226
 227       debug( "opa->type = <0x%x>, opb->type = <0x%x>!\n",
 228              opa->type, opb->type );
 229
 230       switch( sym->type )
 231         {
 232         case OP_ASSIGN_EVAL:
 233           res = gpy_process_assign( &opa, &opb, context );
 234           break;
 235
 236         case OP_BIN_ADDITION:
 237           res = gpy_process_bin_expression( &opa, &opb, sym->type, context );
 238           break;
 239
 240         default:
 241           fatal_error( "invalid expression evaluation symbol type <0x%x>!\n",
 242                        sym->type );
 243           break;
 244         }
 245       if( res ) { retval = res; }
 246       else { fatal_error("error evaluating expression!\n"); }
 247     }
 248
 249   return retval;
 250 }
 251
 252 VEC(tree,gc) * gpy_process_functor( const gpy_symbol_obj * const  functor,
 253                                     const char * base_ident,
 254                                     VEC(gpy_ctx_t,gc) * context )
 255 {
 256   VEC(tree,gc) * retval_vec = VEC_alloc (tree,gc,0);
 257
 258   gpy_symbol_obj * o = functor->op_a.symbol_table;
 259   tree fntype = build_function_type(void_type_node, void_list_node);
 260   tree retval = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 261                             get_identifier( functor->identifier ),
 262                             fntype );
 263
 264   tree declare_vars = NULL_TREE;
 265   tree bind = NULL_TREE;
 266   tree block = alloc_stmt_list( );
 267   tree resdecl = NULL_TREE;
 268   tree restype = TREE_TYPE(retval);
 269
 270   int idx = 0;
 271   gpy_context_branch *co = NULL;
 272   gpy_ident it = NULL;
 273
 274   if( base_ident )
 275     {
 276       size_t len = strlen( functor->identifier ) + strlen( base_ident );
 277       size_t idx = 0, idy = 0;
 278       char * buffer = (char *) xmalloc( (sizeof(char) * len)+2 );
 279       for( ; idx<strlen( base_ident ); ++idx )
 280         {
 281           buffer[ idy ] = base_ident[ idx ];
 282           idy++;
 283         }
 284       buffer[ idy ] = '.'; idy++;
 285       for( idx=0; idx<strlen( functor->identifier ); ++idx )
 286         {
 287           buffer[ idy ] = functor->identifier[ idx ];
 288           idy++;
 289         }
 290       buffer[idy] = '\0';
 291       debug("buffer = <%s>!\n", buffer );
 292       SET_DECL_ASSEMBLER_NAME( retval, get_identifier( buffer ) );
 293       free( buffer );
 294     }
 295   else
 296     SET_DECL_ASSEMBLER_NAME( retval, get_identifier(functor->identifier) );
 297
 298   TREE_PUBLIC(retval) = 1;
 299   TREE_STATIC(retval) = 1;
 300
 301   resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 302                         restype );
 303   DECL_CONTEXT(resdecl) = retval;
 304   DECL_RESULT(retval) = resdecl;
 305
 306   DECL_INITIAL(retval) = block;
 307
 308   /* push a new context for local symbols */
 309   co = (gpy_context_branch *)
 310     xmalloc( sizeof(gpy_context_branch) );
 311   gpy_init_ctx_branch( &co );
 312   VEC_safe_push( gpy_ctx_t, gc, context, co );
 313
 314   while( o )
 315     {
 316       /* looping over the gpy_symbol_obj block of function statements
 317          and getting the respective tree's and creating the GENERIC block
 318        */
 319       VEC(tree,gc) * x = gpy_get_tree( o,context );
 320       int itx = 0; tree xt;
 321       for( ; VEC_iterate(tree,x,itx,xt); ++itx )
 322         {
 323           gcc_assert( xt );
 324           append_to_statement_list( xt, &block );
 325         }
 326       o = o->next;
 327     }
 328
 329   for( ; VEC_iterate( gpy_ident,co->var_decl_t, idx, it ); ++idx )
 330     {
 331       /* get all block var_decls */
 332       tree x = gpy_ctx_lookup_decl( context, it->ident, VAR );
 333       gcc_assert( TREE_CODE( x ) == VAR_DECL );
 334       debug("got var decl <%p>:<%s> within func <%s>!\n", (void*)x,
 335             it->ident, functor->identifier );
 336       TREE_CHAIN( x ) = declare_vars;
 337       declare_vars = x;
 338     }
 339
 340   if( declare_vars != NULL_TREE )
 341     {
 342       tree bl = make_node(BLOCK);
 343       BLOCK_SUPERCONTEXT(bl) = retval;
 344       DECL_INITIAL(retval) = bl;
 345       BLOCK_VARS(bl) = declare_vars;
 346       TREE_USED(bl) = 1;
 347       bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(bl),
 348                     NULL_TREE, bl);
 349       TREE_SIDE_EFFECTS(bind) = 1;
 350     }
 351   BIND_EXPR_BODY(bind) = block;
 352   block = bind;
 353   DECL_SAVED_TREE(retval) = block;
 354
 355   VEC_pop( gpy_ctx_t, gpy_ctx_table );
 356
 357   gimplify_function_tree (retval);
 358
 359   cgraph_add_new_function (retval, false);
 360   cgraph_finalize_function (retval, true);
 361
 362   VEC_safe_push( tree,gc,retval_vec,retval );
 363
 364   return retval_vec;
 365 }
 366
 367 VEC(tree,gc) * gpy_process_print( gpy_symbol_obj *sym,
 368                                   VEC(gpy_ctx_t,gc) * context )
 369 {
 370   VEC(tree,gc) * retval = NULL;
 371   gcc_assert( sym->op_a_t == TYPE_SYMBOL );
 372   gpy_symbol_obj * argument_list = sym->op_a.symbol_table;
 373
 374   if( argument_list )
 375     {
 376       int len = 0;
 377       gpy_symbol_obj * t = argument_list;
 378       while( t )
 379         {
 380           len++;
 381           t=t->next;
 382         }
 383
 384       int idx, idy = 0; t = argument_list;
 385       tree * args = XNEWVEC( tree,len );
 386       for( idx=0; idx<len; ++idx )
 387         {
 388           VEC(tree,gc) * x = gpy_get_tree( t, context );
 389           gcc_assert( VEC_length(tree,x) == 1 );
 390           args[ idy ] = VEC_index(tree,x,0);
 391           idy++;
 392           t = t->next;
 393         }
 394
 395       VEC_safe_push( tree,gc,retval,gpy_builtin_get_print_call( len, args ) );
 396     }
 397   else
 398     error("print call without any arguments!\n");
 399
 400   return retval;
 401 }
 402
 403 VEC(tree,gc) * gpy_process_class( gpy_symbol_obj * const sym,
 404                                   VEC(gpy_ctx_t,gc) * context )
 405 {
 406   VEC(tree,gc) * retval = NULL;
 407   return retval;
 408 }
 409
 410 VEC(tree,gc) * gpy_get_tree( gpy_symbol_obj * sym,
 411                              VEC(gpy_ctx_t,gc) * context )
 412 {
 413   VEC(tree,gc) * retval = NULL;
 414
 415   debug( "processing decl of type <0x%X> object <%p>\n",
 416          sym->type, (void*) sym );
 417
 418   if( sym->exp == OP_EXPRESS )
 419     {
 420       sym = gpy_process_AST_Align( &sym );
 421       retval = gpy_process_expression( sym, context );
 422     }
 423   else
 424     {
 425       switch( sym->type )
 426         {
 427         case STRUCTURE_OBJECT_DEF:
 428           {
 429             VEC(gpy_ctx_t,gc) * class_ctx = VEC_alloc(gpy_ctx_t,gc,0);
 430             retval = gpy_process_class( sym, class_ctx );
 431           }
 432           break;
 433
 434         case STRUCTURE_FUNCTION_DEF:
 435           {
 436             VEC(gpy_ctx_t,gc) * func_ctx = VEC_alloc(gpy_ctx_t,gc,0);
 437             retval = gpy_process_functor( sym, NULL, func_ctx );
 438           }
 439           break;
 440
 441         case KEY_PRINT:
 442           retval = gpy_process_print( sym, context );
 443           break;
 444
 445         default:
 446           fatal_error("unhandled symbol type <0x%x>\n", sym->type );
 447           break;
 448         }
 449     }
 450
 451   return retval;
 452 }
 453
 454 tree gpy_main_method_decl( VEC(tree,gc) * block, gpy_context_branch * co )
 455 {
 456   tree retval = NULL_TREE; int idx;
 457
 458   tree main_fn_type = build_function_type_list( integer_type_node, NULL_TREE );
 459   tree main_fn_decl = build_decl( BUILTINS_LOCATION, FUNCTION_DECL,
 460                                   get_identifier("main"), main_fn_type );
 461
 462   DECL_CONTEXT(main_fn_decl) = NULL_TREE;
 463   TREE_STATIC(main_fn_decl) = true;
 464   TREE_PUBLIC(main_fn_decl) = true;
 465   DECL_ARGUMENTS(main_fn_decl) = NULL_TREE;
 466
 467   /* Define the return type (represented by RESULT_DECL) for the main functin */
 468   tree main_ret = build_decl( BUILTINS_LOCATION, RESULT_DECL,
 469                               NULL_TREE, TREE_TYPE(main_fn_type) );
 470   DECL_CONTEXT(main_ret) = main_fn_decl;
 471   DECL_ARTIFICIAL(main_ret) = true;
 472   DECL_IGNORED_P(main_ret) = true;
 473
 474   DECL_RESULT(main_fn_decl) = main_ret;
 475
 476   tree main_art_block = build_block(NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
 477   DECL_INITIAL(main_fn_decl) = main_art_block;
 478
 479   tree declare_vars = NULL_TREE;
 480   tree main_stmts = alloc_stmt_list( );
 481
 482   append_to_statement_list( gpy_builtin_get_init_call( ), &main_stmts );
 483
 484   tree it = NULL_TREE;
 485   for( idx = 0; VEC_iterate(tree,block,idx,it); ++idx )
 486     {
 487       gcc_assert( it );
 488       append_to_statement_list( it, &main_stmts );
 489     }
 490
 491   int block_decl_len = 0; gpy_ident vit = NULL;
 492   for( idx = 0; VEC_iterate( gpy_ident,co->var_decl_t, idx, vit ); ++idx )
 493     {
 494       /* get all block var_decls */
 495       tree x = gpy_ctx_lookup_decl( gpy_ctx_table, vit->ident, VAR );
 496       gcc_assert( TREE_CODE( x ) == VAR_DECL );
 497       debug("got var decl <%p>:<%s> within func <%s>!\n", (void*)x,
 498             vit->ident, "main" );
 499       TREE_CHAIN( x ) = declare_vars;
 500       declare_vars = x;
 501       block_decl_len++;
 502     }
 503
 504   if( block_decl_len > 0 )
 505     {
 506       tree * block_decl_vec = XNEWVEC( tree, block_decl_len );
 507       int idy = 0;
 508
 509       for( idx = 0; VEC_iterate( gpy_ident,co->var_decl_t, idx, vit ); ++idx )
 510         {
 511           tree x = gpy_ctx_lookup_decl( gpy_ctx_table, vit->ident, VAR );
 512           gcc_assert( TREE_CODE( x ) == VAR_DECL );
 513
 514           block_decl_vec[ idy ] = x;
 515           idy++;
 516         }
 517       //block_decl_vec[ idy ] = main_ret; idy++;
 518       append_to_statement_list( gpy_builtin_get_finalize_block_call( block_decl_len,
 519                                                                      block_decl_vec ),
 520                                 &main_stmts );
 521     }
 522   else
 523     {
 524       declare_vars = main_ret;
 525     }
 526
 527   append_to_statement_list( gpy_builtin_get_cleanup_final_call( ), &main_stmts );
 528
 529   tree main_set_ret = build2( MODIFY_EXPR, TREE_TYPE(main_ret),
 530                               main_ret, build_int_cst(integer_type_node, 0));
 531   tree main_ret_expr = build1( RETURN_EXPR, void_type_node, main_set_ret );
 532   append_to_statement_list( main_ret_expr, &main_stmts );
 533
 534   tree bind = NULL_TREE;
 535   if( declare_vars != NULL_TREE )
 536     {
 537       tree bl = make_node(BLOCK);
 538       BLOCK_SUPERCONTEXT(bl) = main_fn_decl;
 539       DECL_INITIAL(main_fn_decl) = bl;
 540       BLOCK_VARS(bl) = declare_vars;
 541       TREE_USED(bl) = 1;
 542       bind = build3( BIND_EXPR, void_type_node, BLOCK_VARS(bl),
 543                      NULL_TREE, bl );
 544       TREE_SIDE_EFFECTS(bind) = 1;
 545     }
 546   BIND_EXPR_BODY(bind) = main_stmts;
 547   main_stmts = bind;
 548   DECL_SAVED_TREE(main_fn_decl) = main_stmts;
 549
 550   gimplify_function_tree( main_fn_decl );
 551   cgraph_finalize_function( main_fn_decl, false );
 552
 553   retval = main_fn_decl;
 554
 555   return retval;
 556 }
 557
 558 void gpy_write_globals (void)
 559 {
 560   gpy_context_branch *co = NULL;
 561   gpy_symbol_obj * it = NULL;
 562   VEC(tree,gc) * main_stmts_vec = VEC_alloc(tree,gc,0);
 563
 564    /* push a new context for local symbols */
 565   co = (gpy_context_branch *)
 566     xmalloc( sizeof(gpy_context_branch) );
 567   gpy_init_ctx_branch( &co );
 568   VEC_safe_push( gpy_ctx_t, gc, gpy_ctx_table, co );
 569
 570   int idx;
 571   for( idx= 0; VEC_iterate(gpy_sym,gpy_decls,idx,it); ++idx )
 572     {
 573       VEC(tree,gc) * x = gpy_get_tree( it, gpy_ctx_table );
 574       gcc_assert( x ); int itx = 0; tree xt;
 575       for( ; VEC_iterate(tree,x,itx,xt); ++itx )
 576         {
 577           if( TREE_CODE(xt) == FUNCTION_DECL )
 578             {
 579               VEC_safe_push (tree,gc,global_decls,xt);
 580             }
 581           else if( TREE_CODE(xt) == VAR_DECL )
 582             {
 583               VEC_safe_push (tree,gc,global_decls,xt);
 584             }
 585           else
 586             {
 587               VEC_safe_push (tree,gc,main_stmts_vec,xt);
 588             }
 589         }
 590     }
 591
 592   VEC_pop( gpy_ctx_t, gpy_ctx_table );
 593
 594   tree itx = NULL_TREE; int idy = 0;
 595   int global_vec_len = VEC_length(tree, global_decls);
 596   tree * global_vec = XNEWVEC( tree, global_vec_len );
 597
 598   FILE *tu_stream = dump_begin (TDI_tu, NULL);
 599   for( idx=0; VEC_iterate(tree,global_decls,idx,itx); ++idx )
 600     {
 601       if (tu_stream)
 602         dump_node(itx, 0, tu_stream);
 603
 604       global_vec[ idy ] = itx;
 605       idy++;
 606     }
 607   if (tu_stream)
 608     dump_end(TDI_tu, tu_stream);
 609
 610   debug("Finished processing!\n\n");
 611
 612   wrapup_global_declarations( global_vec, global_vec_len );
 613
 614   check_global_declarations( global_vec, global_vec_len );
 615   emit_debug_global_declarations( global_vec, global_vec_len );
 616
 617   cgraph_finalize_compilation_unit( );
 618
 619   debug("finished passing to middle-end!\n\n");
 620 }