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