gcc/python/py-runtime.c

   1
   2 /* This file is part of GCC.
   3
   4 GCC is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 3, or (at your option) any later
   7 version.
   8
   9 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with GCC; see the file COPYING3.  If not see
  16 <http://www.gnu.org/licenses/>.  */
  17
  18 /*
  19    This file was generated via autogen @see py-runtime.{def/tpl}
  20      - To regenerate with new definitions $ autogen py-runtime.def
  21  */
  22
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "ansidecl.h"
  27 #include "coretypes.h"
  28 #include "tm.h"
  29 #include "opts.h"
  30 #include "tree.h"
  31 #include "tree-iterator.h"
  32 #include "tree-pass.h"
  33 #include "gimple.h"
  34 #include "toplev.h"
  35 #include "debug.h"
  36 #include "options.h"
  37 #include "flags.h"
  38 #include "convert.h"
  39 #include "diagnostic-core.h"
  40 #include "langhooks.h"
  41 #include "langhooks-def.h"
  42 #include "target.h"
  43 #include "cgraph.h"
  44
  45 #include <gmp.h>
  46 #include <mpfr.h>
  47
  48 #include <gpython.h>
  49 #include <py-il-dot.h>
  50 #include <py-il-tree.h>
  51 #include <py-runtime.h>
  52 #include <py-vec.h>
  53
  54 VEC(tree,gc) * gpy_builtin_types_vec;
  55 static tree gpy_build_py_object_type (void);
  56 static tree gpy_build_py_vector_type (void);
  57
  58
  59 tree GPY_RR_extend_globl_stack (tree size)
  60 {
  61   tree fntype = build_function_type_list (void_type_node,
  62                          integer_type_node,
  63                          NULL_TREE);
  64   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
  65                             get_identifier ("gpy_rr_extend_runtime_stack"),
  66                             fntype);
  67   tree restype = TREE_TYPE (fndecl);
  68   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
  69                              restype);
  70   DECL_CONTEXT (resdecl) = fndecl;
  71   DECL_RESULT (fndecl) = resdecl;
  72   DECL_EXTERNAL (fndecl) = 1;
  73   TREE_PUBLIC (fndecl) = 1;
  74
  75   return build_call_expr (fndecl, 1, size);
  76 }
  77
  78 tree GPY_RR_fold_attrib (tree ident, tree addr, tree offset)
  79 {
  80   tree fntype = build_function_type_list (gpy_attrib_type_ptr,
  81                          gpy_const_char_ptr,
  82                          gpy_unsigned_char_ptr,
  83                          integer_type_node,
  84                          NULL_TREE);
  85   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
  86                             get_identifier ("gpy_rr_fold_attribute"),
  87                             fntype);
  88   tree restype = TREE_TYPE (fndecl);
  89   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
  90                              restype);
  91   DECL_CONTEXT (resdecl) = fndecl;
  92   DECL_RESULT (fndecl) = resdecl;
  93   DECL_EXTERNAL (fndecl) = 1;
  94   TREE_PUBLIC (fndecl) = 1;
  95
  96   return build_call_expr (fndecl, 3, ident, addr, offset);
  97 }
  98
  99 tree GPY_RR_fold_attrib_list (VEC(tree,gc) * attribs)
 100 {
 101   tree fntype = build_function_type_list (gpy_attrib_type_ptr_ptr,
 102                          integer_type_node,
 103                          va_list_type_node,
 104                          NULL_TREE);
 105   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 106                             get_identifier ("gpy_rr_fold_attrib_list"),
 107                             fntype);
 108   tree restype = TREE_TYPE (fndecl);
 109   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 110                              restype);
 111   DECL_CONTEXT (resdecl) = fndecl;
 112   DECL_RESULT (fndecl) = resdecl;
 113   DECL_EXTERNAL (fndecl) = 1;
 114   TREE_PUBLIC (fndecl) = 1;
 115
 116   return build_call_expr_loc_vec (BUILTINS_LOCATION, fndecl, attribs);
 117 }
 118
 119 tree GPY_RR_fold_class_decl (tree attrib_list, tree size, tree identifier)
 120 {
 121   tree fntype = build_function_type_list (gpy_object_type_ptr,
 122                          gpy_attrib_type_ptr_ptr,
 123                          integer_type_node,
 124                          gpy_const_char_ptr,
 125                          NULL_TREE);
 126   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 127                             get_identifier ("gpy_rr_fold_class_decl"),
 128                             fntype);
 129   tree restype = TREE_TYPE (fndecl);
 130   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 131                              restype);
 132   DECL_CONTEXT (resdecl) = fndecl;
 133   DECL_RESULT (fndecl) = resdecl;
 134   DECL_EXTERNAL (fndecl) = 1;
 135   TREE_PUBLIC (fndecl) = 1;
 136
 137   return build_call_expr (fndecl, 3, attrib_list, size, identifier);
 138 }
 139
 140 tree GPY_RR_fold_integer (tree integer)
 141 {
 142   tree fntype = build_function_type_list (gpy_object_type_ptr,
 143                          integer_type_node,
 144                          NULL_TREE);
 145   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 146                             get_identifier ("gpy_rr_fold_integer"),
 147                             fntype);
 148   tree restype = TREE_TYPE (fndecl);
 149   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 150                              restype);
 151   DECL_CONTEXT (resdecl) = fndecl;
 152   DECL_RESULT (fndecl) = resdecl;
 153   DECL_EXTERNAL (fndecl) = 1;
 154   TREE_PUBLIC (fndecl) = 1;
 155
 156   return build_call_expr (fndecl, 1, integer);
 157 }
 158
 159 tree GPY_RR_get_object_state (tree obj)
 160 {
 161   tree fntype = build_function_type_list (ptr_type_node,
 162                          gpy_object_type_ptr,
 163                          NULL_TREE);
 164   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 165                             get_identifier ("gpy_rr_get_object_state"),
 166                             fntype);
 167   tree restype = TREE_TYPE (fndecl);
 168   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 169                              restype);
 170   DECL_CONTEXT (resdecl) = fndecl;
 171   DECL_RESULT (fndecl) = resdecl;
 172   DECL_EXTERNAL (fndecl) = 1;
 173   TREE_PUBLIC (fndecl) = 1;
 174
 175   return build_call_expr (fndecl, 1, obj);
 176 }
 177
 178 tree GPY_RR_incr_ref_count (tree obj)
 179 {
 180   tree fntype = build_function_type_list (void_type_node,
 181                          gpy_object_type_ptr,
 182                          NULL_TREE);
 183   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 184                             get_identifier ("gpy_rr_incr_ref_count"),
 185                             fntype);
 186   tree restype = TREE_TYPE (fndecl);
 187   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 188                              restype);
 189   DECL_CONTEXT (resdecl) = fndecl;
 190   DECL_RESULT (fndecl) = resdecl;
 191   DECL_EXTERNAL (fndecl) = 1;
 192   TREE_PUBLIC (fndecl) = 1;
 193
 194   return build_call_expr (fndecl, 1, obj);
 195 }
 196
 197 tree GPY_RR_decr_ref_count (tree obj)
 198 {
 199   tree fntype = build_function_type_list (void_type_node,
 200                          gpy_object_type_ptr,
 201                          NULL_TREE);
 202   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 203                             get_identifier ("gpy_rr_decr_ref_count"),
 204                             fntype);
 205   tree restype = TREE_TYPE (fndecl);
 206   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 207                              restype);
 208   DECL_CONTEXT (resdecl) = fndecl;
 209   DECL_RESULT (fndecl) = resdecl;
 210   DECL_EXTERNAL (fndecl) = 1;
 211   TREE_PUBLIC (fndecl) = 1;
 212
 213   return build_call_expr (fndecl, 1, obj);
 214 }
 215
 216 tree GPY_RR_eval_print (VEC(tree,gc) * arguments)
 217 {
 218   tree fntype = build_function_type_list (void_type_node,
 219                          integer_type_node,
 220                          integer_type_node
 221                          va_list_type_node,
 222                          NULL_TREE);
 223   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 224                             get_identifier ("gpy_rr_eval_print"),
 225                             fntype);
 226   tree restype = TREE_TYPE (fndecl);
 227   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 228                              restype);
 229   DECL_CONTEXT (resdecl) = fndecl;
 230   DECL_RESULT (fndecl) = resdecl;
 231   DECL_EXTERNAL (fndecl) = 1;
 232   TREE_PUBLIC (fndecl) = 1;
 233
 234   return build_call_expr_loc_vec (BUILTINS_LOCATION, fndecl, arguments);
 235 }
 236
 237 tree GPY_RR_eval_expression (tree x, tree y, tree op)
 238 {
 239   tree fntype = build_function_type_list (gpy_object_type_ptr,
 240                          gpy_object_type_ptr,
 241                          integer_type_node
 242                          NULL_TREE);
 243   tree fndecl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
 244                             get_identifier ("gpy_rr_eval_expression"),
 245                             fntype);
 246   tree restype = TREE_TYPE (fndecl);
 247   tree resdecl = build_decl (BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
 248                              restype);
 249   DECL_CONTEXT (resdecl) = fndecl;
 250   DECL_RESULT (fndecl) = resdecl;
 251   DECL_EXTERNAL (fndecl) = 1;
 252   TREE_PUBLIC (fndecl) = 1;
 253
 254   return build_call_expr (fndecl, 3, x, y, op);
 255 }
 256
 257
 258 static
 259 tree gpy_build_py_vector_type (void)
 260 {
 261   tree vec_struct_type = make_node (RECORD_TYPE);
 262
 263   tree field = build_decl (BUILTINS_LOCATION, FIELD_DECL, get_identifier ("vector"),
 264                            build_pointer_type (ptr_type_node));
 265   DECL_CONTEXT (field) = vec_struct_type;
 266   TYPE_FIELDS (vec_struct_type) = field;
 267   tree last_field = field;
 268
 269   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, get_identifier ("size"),
 270                       integer_type_node);
 271   DECL_CONTEXT (field) = vec_struct_type;
 272   DECL_CHAIN (last_field) = field;
 273   last_field = field;
 274
 275   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, get_identifier ("length"),
 276                       integer_type_node);
 277   DECL_CONTEXT (field) = vec_struct_type;
 278   DECL_CHAIN (last_field) = field;
 279
 280   layout_type (vec_struct_type);
 281   tree ident = get_identifier ("gpy_vector_t");
 282   tree type_decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, ident,
 283                                vec_struct_type);
 284   DECL_ARTIFICIAL (type_decl) = 1;
 285   TYPE_NAME (vec_struct_type) = ident;
 286
 287   gpy_preserve_from_gc (type_decl);
 288   rest_of_decl_compilation (type_decl, 1, 0);
 289
 290   return vec_struct_type;
 291 }
 292
 293 static
 294 tree gpy_build_py_attrib_type (void)
 295 {
 296   tree attrib_struct_type = make_node (RECORD_TYPE);
 297
 298   tree field = build_decl (BUILTINS_LOCATION, FIELD_DECL,
 299                            get_identifier ("identifier"),
 300                            gpy_const_char_ptr);
 301   DECL_CONTEXT (field) = attrib_struct_type;
 302   TYPE_FIELDS (attrib_struct_type) = field;
 303
 304   tree last_field = field;
 305
 306   field = build_decl (BUILTINS_LOCATION, FIELD_DECL,
 307                       get_identifier ("offset"),
 308                       unsigned_type_node);
 309   DECL_CONTEXT (field) = attrib_struct_type;
 310   DECL_CHAIN (last_field) = field;
 311   last_field = field;
 312
 313   field = build_decl (BUILTINS_LOCATION, FIELD_DECL,
 314                       get_identifier ("addr"),
 315                       gpy_object_type_ptr);
 316   DECL_CONTEXT (field) = attrib_struct_type;
 317   DECL_CHAIN (last_field) = field;
 318
 319   layout_type (attrib_struct_type);
 320   tree ident = get_identifier ("gpy_object_attrib_t");
 321   tree type_decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, ident,
 322                                attrib_struct_type);
 323   DECL_ARTIFICIAL (type_decl) = 1;
 324   TYPE_NAME (attrib_struct_type) = ident;
 325
 326   gpy_preserve_from_gc (type_decl);
 327   rest_of_decl_compilation (type_decl, 1, 0);
 328
 329   return attrib_struct_type;
 330 }
 331
 332 static
 333 tree gpy_build_py_object_type (void)
 334 {
 335   tree object_state_struct_Type = make_node (RECORD_TYPE);
 336
 337   tree name = get_identifier("identifier");
 338   tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
 339                           build_pointer_type(char_type_node));
 340   DECL_CONTEXT(field) = object_state_struct_Type;
 341   TYPE_FIELDS(object_state_struct_Type) = field;
 342   tree last_field = field;
 343
 344   name = get_identifier("ref_count");
 345   field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, integer_type_node);
 346   DECL_CONTEXT(field) = object_state_struct_Type;
 347   DECL_CHAIN(last_field) = field;
 348   last_field = field;
 349
 350   name = get_identifier("state");
 351   field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
 352                      ptr_type_node);
 353   DECL_CONTEXT(field) = object_state_struct_Type;
 354   DECL_CHAIN(last_field) = field;
 355   last_field = field;
 356
 357   name = get_identifier("definition");
 358   field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
 359                      ptr_type_node);
 360   DECL_CONTEXT(field) = object_state_struct_Type;
 361   DECL_CHAIN(last_field) = field;
 362   last_field = field;
 363
 364   layout_type(object_state_struct_Type);
 365
 366   // Give the struct a name for better debugging info.
 367   name = get_identifier ("gpy_object_state_t");
 368   tree object_state_type_decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, name,
 369                                             object_state_struct_Type);
 370   DECL_ARTIFICIAL(object_state_type_decl) = 1;
 371   TYPE_NAME(object_state_struct_Type) = object_state_type_decl;
 372   gpy_preserve_from_gc(object_state_type_decl);
 373   rest_of_decl_compilation(object_state_type_decl, 1, 0);
 374
 375   debug_tree (object_state_type_decl);
 376   tree object_state_ptr_type = build_pointer_type (object_state_struct_Type);
 377   gpy_preserve_from_gc (object_state_ptr_type);
 378
 379   tree union_type__ = make_node (UNION_TYPE);
 380
 381   name = get_identifier ("object_state");
 382   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, name,
 383                       object_state_ptr_type);
 384   DECL_CONTEXT(field) = union_type__;
 385   DECL_CHAIN(last_field) = field;
 386   last_field = field;
 387
 388   name = get_identifier ("literal");
 389   field = build_decl (BUILTINS_LOCATION, FIELD_DECL, name,
 390                       ptr_type_node);
 391   DECL_CONTEXT(field) = union_type__;
 392   DECL_CHAIN(last_field) = field;
 393   last_field = field;
 394
 395   layout_type (union_type__);
 396
 397   name = get_identifier("o");
 398   tree union_type_decl = build_decl(BUILTINS_LOCATION, TYPE_DECL, name,
 399                                     union_type__);
 400   DECL_ARTIFICIAL(union_type_decl) = 1;
 401   TYPE_NAME(union_type__) = union_type_decl;
 402   gpy_preserve_from_gc(union_type_decl);
 403   rest_of_decl_compilation(union_type_decl, 1, 0);
 404
 405   tree gpy_object_struct_Type = make_node (RECORD_TYPE);
 406
 407   name = get_identifier("type");
 408   field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, integer_type_node);
 409   DECL_CONTEXT(field) = gpy_object_struct_Type;
 410   DECL_CHAIN(last_field) = field;
 411   last_field = field;
 412
 413   field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
 414                      union_type_decl);
 415   DECL_CONTEXT(field) = gpy_object_struct_Type;
 416   DECL_CHAIN(last_field) = field;
 417   last_field = field;
 418
 419   layout_type (object_state_struct_Type);
 420
 421   name = get_identifier ("gpy_object_t");
 422   tree gpy_object_type_decl = build_decl(BUILTINS_LOCATION, TYPE_DECL, name,
 423                                          gpy_object_struct_Type);
 424   DECL_ARTIFICIAL(gpy_object_type_decl) = 1;
 425   TYPE_NAME(gpy_object_struct_Type) = name;
 426   gpy_preserve_from_gc(gpy_object_type_decl);
 427   rest_of_decl_compilation(gpy_object_type_decl, 1, 0);
 428
 429   return build_pointer_type (gpy_object_struct_Type);
 430 }
 431
 432 void gpy_initilize_types (void)
 433 {
 434   gpy_builtin_types_vec = VEC_alloc (tree,gc,0);
 435
 436   tree const_char_type = build_qualified_type (unsigned_char_type_node,
 437                                                TYPE_QUAL_CONST);
 438   tree ctype = build_pointer_type (const_char_type);
 439
 440   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 441                  gpy_build_py_object_type ());
 442   gpy_preserve_from_gc (gpy_object_type_ptr);
 443
 444   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 445                  build_pointer_type (gpy_object_type_ptr));
 446   gpy_preserve_from_gc (gpy_object_type_ptr_ptr);
 447
 448   VEC_safe_push (tree, gc, gpy_builtin_types_vec, ctype);
 449   gpy_preserve_from_gc (gpy_const_char_ptr);
 450
 451   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 452                  gpy_build_py_vector_type ());
 453   gpy_preserve_from_gc (gpy_vector_type);
 454
 455   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 456                  build_pointer_type (gpy_vector_type));
 457   gpy_preserve_from_gc (gpy_vector_type_ptr);
 458
 459   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 460                  build_pointer_type (gpy_vector_type_ptr));
 461   gpy_preserve_from_gc (gpy_vector_type_ptr_ptr);
 462
 463   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 464                  gpy_build_py_attrib_type ());
 465   gpy_preserve_from_gc (gpy_attrib_type);
 466
 467   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 468                  gpy_attrib_type);
 469   gpy_preserve_from_gc (gpy_attrib_type_ptr);
 470
 471   VEC_safe_push (tree, gc, gpy_builtin_types_vec,
 472                  build_pointer_type (gpy_attrib_type_ptr));
 473   gpy_preserve_from_gc (gpy_attrib_type_ptr_ptr);
 474 }
 475
 476