gcc/python/py-runtime.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 "gimple.h"
  24 #include "toplev.h"
  25 #include "debug.h"
  26 #include "options.h"
  27 #include "flags.h"
  28 #include "convert.h"
  29 #include "diagnostic-core.h"
  30 #include "langhooks.h"
  31 #include "langhooks-def.h"
  32 #include "target.h"
  33
  34 #include <gmp.h>
  35 #include <mpfr.h>
  36
  37 #include "vec.h"
  38 #include "hashtab.h"
  39
  40 #include "gpython.h"
  41 #include "py-dot-codes.def"
  42 #include "py-dot.h"
  43 #include "py-vec.h"
  44 #include "py-tree.h"
  45 #include "py-types.h"
  46 #include "py-runtime.h"
  47
  48 VEC(tree,gc) * gpy_builtin_get_init_call (void)
  49 {
  50   tree fntype = build_function_type( void_type_node, void_list_node );
  51   tree gpy_rr_init = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
  52                                  get_identifier("gpy_rr_init_runtime"),
  53                                  fntype );
  54   tree restype = TREE_TYPE(gpy_rr_init);
  55   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
  56                              restype );
  57   DECL_CONTEXT(resdecl) = gpy_rr_init;
  58   DECL_RESULT(gpy_rr_init) = resdecl;
  59   DECL_EXTERNAL( gpy_rr_init ) = 1;
  60   TREE_PUBLIC( gpy_rr_init ) = 1;
  61
  62   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
  63   VEC_safe_push (tree,gc,retval,
  64                  build_call_expr( gpy_rr_init, 0, NULL_TREE ));
  65
  66   return retval;
  67 }
  68
  69 VEC(tree,gc) * gpy_builtin_get_cleanup_final_call( void )
  70 {
  71   tree fntype = build_function_type( void_type_node, void_list_node );
  72   tree gpy_rr_cleanup = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
  73                                     get_identifier("gpy_rr_cleanup_final"),
  74                                     fntype );
  75   tree restype = TREE_TYPE( gpy_rr_cleanup );
  76   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
  77                              restype );
  78   DECL_CONTEXT(resdecl) = gpy_rr_cleanup;
  79   DECL_RESULT(gpy_rr_cleanup) = resdecl;
  80   DECL_EXTERNAL( gpy_rr_cleanup ) = 1;
  81   TREE_PUBLIC( gpy_rr_cleanup ) = 1;
  82
  83   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
  84   VEC_safe_push (tree,gc,retval,
  85                  build_call_expr( gpy_rr_cleanup, 0, NULL_TREE ));
  86
  87   return retval;
  88 }
  89
  90 VEC(tree,gc) * gpy_builtin_get_push_context_call( void )
  91 {
  92   tree fntype = build_function_type( void_type_node, void_list_node );
  93   tree gpy_rr_push = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
  94                                  get_identifier("gpy_rr_push_context"),
  95                                  fntype );
  96   tree restype = TREE_TYPE( gpy_rr_push );
  97   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
  98                              restype );
  99   DECL_CONTEXT(resdecl) = gpy_rr_push;
 100   DECL_RESULT(gpy_rr_push) = resdecl;
 101   DECL_EXTERNAL( gpy_rr_push ) = 1;
 102   TREE_PUBLIC( gpy_rr_push ) = 1;
 103
 104   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
 105   VEC_safe_push (tree,gc,retval,
 106                  build_call_expr( gpy_rr_push, 0, NULL_TREE )
 107                  );
 108
 109   return retval;
 110 }
 111
 112 VEC(tree,gc) * gpy_builtin_get_pop_context_call( void )
 113 {
 114   tree fntype = build_function_type( void_type_node, void_list_node );
 115   tree gpy_rr_pop = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 116                                  get_identifier("gpy_rr_pop_context"),
 117                                  fntype );
 118   tree restype = TREE_TYPE( gpy_rr_pop );
 119   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 120                              restype );
 121   DECL_CONTEXT(resdecl) = gpy_rr_pop;
 122   DECL_RESULT(gpy_rr_pop) = resdecl;
 123   DECL_EXTERNAL( gpy_rr_pop ) = 1;
 124   TREE_PUBLIC( gpy_rr_pop ) = 1;
 125
 126   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
 127   VEC_safe_push (tree,gc,retval,
 128                  build_call_expr( gpy_rr_pop, 0, NULL_TREE ));
 129
 130   return retval;
 131 }
 132
 133 VEC(tree,gc) * gpy_builtin_get_fold_int_call( int val )
 134 {
 135   tree params = NULL_TREE;
 136
 137   chainon( params, tree_cons (NULL_TREE, integer_type_node, NULL_TREE) );
 138   chainon( params, tree_cons (NULL_TREE, void_type_node, NULL_TREE) );
 139
 140   tree fntype = build_function_type( ptr_type_node, params );
 141   tree gpy_eval_expr_decl = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 142                                         get_identifier("gpy_rr_fold_integer"),
 143                                         fntype );
 144   tree restype = TREE_TYPE(gpy_eval_expr_decl);
 145   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 146                              restype );
 147   DECL_CONTEXT(resdecl) = gpy_eval_expr_decl;
 148   DECL_RESULT(gpy_eval_expr_decl) = resdecl;
 149   DECL_EXTERNAL( gpy_eval_expr_decl ) = 1;
 150   TREE_PUBLIC( gpy_eval_expr_decl ) = 1;
 151
 152   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
 153   VEC_safe_push (tree,gc,retval,
 154                  build_call_expr (gpy_eval_expr_decl, 1,
 155                                   build_int_cst (integer_type_node,
 156                                                  val)
 157                                   )
 158                             );
 159
 160   return retval;
 161 }
 162
 163 VEC(tree,gc) * gpy_builtin_get_eval_expression_call( tree t1, tree t2, gpy_opcode_t op )
 164 {
 165   tree params = NULL_TREE;
 166
 167   chainon( params, tree_cons (NULL_TREE, ptr_type_node, NULL_TREE) );
 168   chainon( params, tree_cons (NULL_TREE, ptr_type_node, NULL_TREE) );
 169   chainon( params, tree_cons (NULL_TREE, integer_type_node, NULL_TREE) );
 170   chainon( params, tree_cons (NULL_TREE, void_type_node, NULL_TREE) );
 171
 172   tree fntype = build_function_type( ptr_type_node, params );
 173   tree gpy_eval_expr_decl = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 174                                         get_identifier("gpy_rr_eval_expression"),
 175                                         fntype );
 176   tree restype = TREE_TYPE(gpy_eval_expr_decl);
 177   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 178                              restype );
 179   DECL_CONTEXT( resdecl ) = gpy_eval_expr_decl;
 180   DECL_RESULT( gpy_eval_expr_decl ) = resdecl;
 181   DECL_EXTERNAL( gpy_eval_expr_decl ) = 1;
 182   TREE_PUBLIC( gpy_eval_expr_decl ) = 1;
 183
 184   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
 185   VEC_safe_push (tree,gc,retval,
 186                   build_call_expr( gpy_eval_expr_decl, 3, t1, t2,
 187                                    build_int_cst( integer_type_node, op ))
 188                  );
 189
 190   return retval;
 191 }
 192
 193 VEC(tree,gc) * gpy_builtin_get_incr_ref_call( tree x )
 194 {
 195   tree params = NULL_TREE;
 196
 197   chainon( params, tree_cons (NULL_TREE, ptr_type_node, NULL_TREE) );
 198   chainon( params, tree_cons (NULL_TREE, void_type_node, NULL_TREE) );
 199
 200   tree fntype = build_function_type( ptr_type_node, params );
 201   tree gpy_incr_ref_decl = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 202                                         get_identifier("gpy_rr_incr_ref_count"),
 203                                         fntype );
 204   tree restype = TREE_TYPE( gpy_incr_ref_decl );
 205   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 206                              restype );
 207   DECL_CONTEXT( resdecl ) = gpy_incr_ref_decl;
 208   DECL_RESULT( gpy_incr_ref_decl ) = resdecl;
 209   DECL_EXTERNAL( gpy_incr_ref_decl ) = 1;
 210   TREE_PUBLIC( gpy_incr_ref_decl ) = 1;
 211
 212   VEC(tree,gc) * retval = VEC_alloc (tree, gc, 0);
 213   VEC_safe_push (tree,gc,retval,
 214                  build_call_expr( gpy_incr_ref_decl, 1, x )
 215                  );
 216
 217   return retval;
 218 }
 219
 220 VEC(tree,gc) * gpy_builtin_get_decr_ref_call( tree x )
 221 {
 222   tree params = NULL_TREE;
 223
 224   chainon( params, tree_cons (NULL_TREE, ptr_type_node, NULL_TREE) );
 225   chainon( params, tree_cons (NULL_TREE, void_type_node, NULL_TREE) );
 226
 227   tree fntype = build_function_type( ptr_type_node, params );
 228   tree gpy_decr_ref_decl = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 229                                         get_identifier("gpy_rr_decr_ref_count"),
 230                                         fntype );
 231   tree restype = TREE_TYPE( gpy_decr_ref_decl );
 232   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 233                              restype );
 234   DECL_CONTEXT( resdecl ) = gpy_decr_ref_decl;
 235   DECL_RESULT( gpy_decr_ref_decl ) = resdecl;
 236   DECL_EXTERNAL( gpy_decr_ref_decl ) = 1;
 237   TREE_PUBLIC( gpy_decr_ref_decl ) = 1;
 238
 239   VEC(tree,gc) * retval = VEC_alloc (tree, gc, 0);
 240   VEC_safe_push(tree,gc,retval,
 241                 build_call_expr( gpy_decr_ref_decl, 1, x )
 242                 );
 243
 244   return retval;
 245 }
 246
 247 VEC(tree,gc) * gpy_builtin_get_print_call( int n, tree * args )
 248 {
 249   tree params = NULL_TREE;
 250
 251   chainon( params, tree_cons (NULL_TREE, integer_type_node, NULL_TREE) );
 252   chainon( params, tree_cons (NULL_TREE, integer_type_node, NULL_TREE) );
 253   chainon( params, tree_cons (NULL_TREE, va_list_type_node, NULL_TREE) );
 254   chainon( params, tree_cons (NULL_TREE, void_type_node, NULL_TREE) );
 255
 256   tree fntype = build_function_type( ptr_type_node, params );
 257   tree gpy_eval_print_decl = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 258                                         get_identifier("gpy_rr_eval_print"),
 259                                         fntype );
 260   tree restype = TREE_TYPE(gpy_eval_print_decl);
 261   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 262                              restype );
 263   DECL_CONTEXT( resdecl ) = gpy_eval_print_decl;
 264   DECL_RESULT( gpy_eval_print_decl ) = resdecl;
 265   DECL_EXTERNAL( gpy_eval_print_decl ) = 1;
 266   TREE_PUBLIC( gpy_eval_print_decl ) = 1;
 267
 268   tree * vec = XNEWVEC( tree, n+2 );
 269
 270   printf("n = <%i>!!\n\n", n );
 271
 272   vec[0] = build_int_cst( integer_type_node, 1 );
 273   vec[1] = build_int_cst( integer_type_node, n );
 274
 275   int idx = 2, idy = 0;
 276   for( ; idy<n; ++idy )
 277     {
 278       vec[idx] = args[idy];
 279       idx++;
 280     }
 281   VEC(tree,gc) * retval = VEC_alloc (tree, gc, 0);
 282   VEC_safe_push (tree,gc,retval,
 283                  build_call_expr_loc_array (UNKNOWN_LOCATION,
 284                                             gpy_eval_print_decl,
 285                                             n+2, vec)
 286                  );
 287   return retval;
 288 }
 289
 290 VEC(tree,gc) * gpy_builtin_get_finalize_block_call (int n, tree * args)
 291 {
 292   tree params = NULL_TREE;
 293
 294   chainon( params, tree_cons (NULL_TREE, integer_type_node, NULL_TREE) );
 295   chainon( params, tree_cons (NULL_TREE, va_list_type_node, NULL_TREE) );
 296   chainon( params, tree_cons (NULL_TREE, void_type_node, NULL_TREE) );
 297
 298   tree fntype = build_function_type( ptr_type_node, params );
 299   tree gpy_finalize_block_decl = build_decl( UNKNOWN_LOCATION, FUNCTION_DECL,
 300                                              get_identifier("gpy_rr_finalize_block_decls"),
 301                                              fntype );
 302
 303   tree restype = TREE_TYPE( gpy_finalize_block_decl );
 304   tree resdecl = build_decl( UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 305                              restype );
 306
 307   DECL_CONTEXT( resdecl ) = gpy_finalize_block_decl;
 308   DECL_RESULT( gpy_finalize_block_decl ) = resdecl;
 309   DECL_EXTERNAL( gpy_finalize_block_decl ) = 1;
 310   TREE_PUBLIC( gpy_finalize_block_decl ) = 1;
 311
 312   tree * vec = XNEWVEC (tree, n+1);
 313
 314   vec[0] = build_int_cst (integer_type_node, n);
 315
 316   int idx = 1, idy = 0;
 317   for( ; idy<n; ++idy )
 318     {
 319       vec[idx] = args[idy];
 320       idx++;
 321     }
 322
 323   VEC(tree,gc) * retval = VEC_alloc (tree, gc, 0);
 324   VEC_safe_push (tree, gc, retval,
 325                  build_call_expr_loc_array (UNKNOWN_LOCATION,
 326                                             gpy_finalize_block_decl,
 327                                             n+1, vec)
 328                  );
 329
 330   return retval;
 331 }
 332
 333 VEC(tree,gc) * gpy_builtin_get_set_decl_call (tree decl)
 334 {
 335   tree params = NULL_TREE;
 336
 337   chainon (params, tree_cons (NULL_TREE, gpy_const_char_ptr, NULL_TREE));
 338   chainon (params, tree_cons (NULL_TREE, gpy_object_type_ptr, NULL_TREE));
 339   chainon (params, tree_cons (NULL_TREE, void_type_node, NULL_TREE));
 340
 341   tree fntype = build_function_type (void_type_node, params);
 342   tree gpy_rr_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
 343                                  get_identifier("gpy_rr_set_decl_val"),
 344                                  fntype);
 345
 346   tree restype = TREE_TYPE (gpy_rr_decl);
 347   tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 348                              restype);
 349
 350   DECL_CONTEXT (resdecl ) = gpy_rr_decl;
 351   DECL_RESULT (gpy_rr_decl ) = resdecl;
 352   DECL_EXTERNAL (gpy_rr_decl ) = 1;
 353   TREE_PUBLIC (gpy_rr_decl ) = 1;
 354
 355   const char * c_ident = IDENTIFIER_POINTER(DECL_NAME(decl));
 356   debug ("c_ident = <%s>!\n", c_ident);
 357
 358   tree str = build_string (strlen (c_ident), c_ident);
 359   TREE_TYPE (str) = gpy_const_char_ptr;
 360   tree ident = build_fold_addr_expr (str);
 361
 362   VEC(tree,gc) * retval = VEC_alloc(tree,gc,0);
 363   VEC_safe_push (tree,gc,retval,
 364                  build_call_expr (gpy_rr_decl, 2, ident, decl)
 365                  );
 366
 367   return retval;
 368 }
 369
 370 VEC(tree,gc) * gpy_builtin_get_register_decl_call (tree decl)
 371 {
 372   tree params = NULL_TREE;
 373   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 374
 375   chainon (params, tree_cons (NULL_TREE, gpy_const_char_ptr, NULL_TREE));
 376   chainon (params, tree_cons (NULL_TREE, void_type_node, NULL_TREE));
 377
 378   tree fntype = build_function_type (void_type_node, params);
 379   tree gpy_rr_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
 380                                  get_identifier("gpy_rr_register_decl"),
 381                                  fntype);
 382
 383   tree restype = TREE_TYPE (gpy_rr_decl);
 384   tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 385                              restype);
 386
 387   DECL_CONTEXT (resdecl ) = gpy_rr_decl;
 388   DECL_RESULT (gpy_rr_decl ) = resdecl;
 389   DECL_EXTERNAL (gpy_rr_decl ) = 1;
 390   TREE_PUBLIC (gpy_rr_decl ) = 1;
 391
 392   const char * c_ident = IDENTIFIER_POINTER(DECL_NAME(decl));
 393   debug ("c_ident = <%s>!\n", c_ident);
 394
 395   tree str = build_string (strlen (c_ident), c_ident);
 396   TREE_TYPE (str) = gpy_const_char_ptr;
 397   tree ident = build_fold_addr_expr (str);
 398
 399   VEC(tree,gc) * retval = VEC_alloc(tree,gc,0);
 400   VEC_safe_push (tree,gc,retval,
 401                  build_call_expr (gpy_rr_decl, 1, ident)
 402                  );
 403
 404   return retval;
 405 }
 406
 407 VEC(tree,gc) * gpy_builtin_get_register_callable_call (tree decl, int n)
 408 {
 409   tree params = NULL_TREE;
 410   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 411
 412   chainon (params, tree_cons (NULL_TREE, ptr_type_node, NULL_TREE));
 413   chainon (params, tree_cons (NULL_TREE, integer_type_node, NULL_TREE));
 414   chainon (params, tree_cons (NULL_TREE, gpy_const_char_ptr, NULL_TREE));
 415   chainon (params, tree_cons (NULL_TREE, void_type_node, NULL_TREE));
 416
 417   tree fntype = build_function_type (void_type_node, params);
 418   tree gpy_rr_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
 419                                  get_identifier("gpy_rr_register_callable"),
 420                                  fntype);
 421
 422   tree restype = TREE_TYPE (gpy_rr_decl);
 423   tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
 424                              restype);
 425
 426   DECL_CONTEXT (resdecl ) = gpy_rr_decl;
 427   DECL_RESULT (gpy_rr_decl ) = resdecl;
 428   DECL_EXTERNAL (gpy_rr_decl ) = 1;
 429   TREE_PUBLIC (gpy_rr_decl ) = 1;
 430
 431   const char * c_ident = IDENTIFIER_POINTER(DECL_NAME(decl));
 432   debug ("c_ident = <%s>!\n", c_ident);
 433
 434   tree str = build_string (strlen (c_ident), c_ident);
 435   TREE_TYPE (str) = gpy_const_char_ptr;
 436   tree ident = build_fold_addr_expr (str);
 437
 438   tree address = build_decl (BUILTINS_LOCATION, VAR_DECL, create_tmp_var_name("C"),
 439                              gpy_const_char_ptr);
 440
 441   VEC(tree,gc) * retval = VEC_alloc (tree,gc,0);
 442
 443   VEC_safe_push (tree, gc, retval,
 444                  build2 (MODIFY_EXPR, gpy_const_char_ptr,
 445                          address, ident));
 446   VEC_safe_push (tree, gc, retval,
 447                  build_call_expr (gpy_rr_decl, 3,
 448                                   build_fold_addr_expr (decl),
 449                                   build_int_cst (integer_type_node, n),
 450                                   ident));
 451   return retval;
 452 }
 453
 454
 455 VEC(tree,gc) * gpy_builtin_get_fold_call_call (const char * ident, int n,
 456                                                tree *args)
 457 {
 458   return NULL;
 459 }
 460
 461 VEC(tree,gc) * gpy_builtin_get_eval_accessor_call (tree t1, tree t2)
 462 {
 463   fatal_error("Accessor's not implemented yet!\n");
 464   return NULL;
 465 }