gcc/go/go-gcc.cc

   1 // go-gcc.cc -- Go frontend to gcc IR.
   2 // Copyright (C) 2011 Free Software Foundation, Inc.
   3 // Contributed by Ian Lance Taylor, Google.
   4
   5 // This file is part of GCC.
   6
   7 // GCC is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU General Public License as published by the Free
   9 // Software Foundation; either version 3, or (at your option) any later
  10 // version.
  11
  12 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 // for more details.
  16
  17 // You should have received a copy of the GNU General Public License
  18 // along with GCC; see the file COPYING3.  If not see
  19 // <http://www.gnu.org/licenses/>.
  20
  21 #include "go-system.h"
  22
  23 // This has to be included outside of extern "C", so we have to
  24 // include it here before tree.h includes it later.
  25 #include <gmp.h>
  26
  27 #ifndef ENABLE_BUILD_WITH_CXX
  28 extern "C"
  29 {
  30 #endif
  31
  32 #include "tree.h"
  33 #include "tree-iterator.h"
  34 #include "gimple.h"
  35 #include "toplev.h"
  36
  37 #ifndef ENABLE_BUILD_WITH_CXX
  38 }
  39 #endif
  40
  41 #include "go-c.h"
  42
  43 #include "gogo.h"
  44 #include "backend.h"
  45
  46 // A class wrapping a tree.
  47
  48 class Gcc_tree
  49 {
  50  public:
  51   Gcc_tree(tree t)
  52     : t_(t)
  53   { }
  54
  55   tree
  56   get_tree() const
  57   { return this->t_; }
  58
  59  private:
  60   tree t_;
  61 };
  62
  63 // In gcc, types, expressions, and statements are all trees.
  64 class Btype : public Gcc_tree
  65 {
  66  public:
  67   Btype(tree t)
  68     : Gcc_tree(t)
  69   { }
  70 };
  71
  72 class Bexpression : public Gcc_tree
  73 {
  74  public:
  75   Bexpression(tree t)
  76     : Gcc_tree(t)
  77   { }
  78 };
  79
  80 class Bstatement : public Gcc_tree
  81 {
  82  public:
  83   Bstatement(tree t)
  84     : Gcc_tree(t)
  85   { }
  86 };
  87
  88 class Bfunction : public Gcc_tree
  89 {
  90  public:
  91   Bfunction(tree t)
  92     : Gcc_tree(t)
  93   { }
  94 };
  95
  96 class Bblock : public Gcc_tree
  97 {
  98  public:
  99   Bblock(tree t)
 100     : Gcc_tree(t)
 101   { }
 102 };
 103
 104 class Bvariable : public Gcc_tree
 105 {
 106  public:
 107   Bvariable(tree t)
 108     : Gcc_tree(t)
 109   { }
 110 };
 111
 112 class Blabel : public Gcc_tree
 113 {
 114  public:
 115   Blabel(tree t)
 116     : Gcc_tree(t)
 117   { }
 118 };
 119
 120 // This file implements the interface between the Go frontend proper
 121 // and the gcc IR.  This implements specific instantiations of
 122 // abstract classes defined by the Go frontend proper.  The Go
 123 // frontend proper class methods of these classes to generate the
 124 // backend representation.
 125
 126 class Gcc_backend : public Backend
 127 {
 128  public:
 129   // Types.
 130
 131   Btype*
 132   error_type()
 133   { return this->make_type(error_mark_node); }
 134
 135   Btype*
 136   void_type()
 137   { return this->make_type(void_type_node); }
 138
 139   Btype*
 140   bool_type()
 141   { return this->make_type(boolean_type_node); }
 142
 143   Btype*
 144   integer_type(bool, int);
 145
 146   Btype*
 147   float_type(int);
 148
 149   Btype*
 150   complex_type(int);
 151
 152   Btype*
 153   pointer_type(Btype*);
 154
 155   Btype*
 156   function_type(const Btyped_identifier&,
 157                 const std::vector<Btyped_identifier>&,
 158                 const std::vector<Btyped_identifier>&,
 159                 const Location);
 160
 161   Btype*
 162   struct_type(const std::vector<Btyped_identifier>&);
 163
 164   Btype*
 165   array_type(Btype*, Bexpression*);
 166
 167   Btype*
 168   placeholder_pointer_type(const std::string&, Location, bool);
 169
 170   bool
 171   set_placeholder_pointer_type(Btype*, Btype*);
 172
 173   bool
 174   set_placeholder_function_type(Btype*, Btype*);
 175
 176   Btype*
 177   placeholder_struct_type(const std::string&, Location);
 178
 179   bool
 180   set_placeholder_struct_type(Btype* placeholder,
 181                               const std::vector<Btyped_identifier>&);
 182
 183   Btype*
 184   placeholder_array_type(const std::string&, Location);
 185
 186   bool
 187   set_placeholder_array_type(Btype*, Btype*, Bexpression*);
 188
 189   Btype*
 190   named_type(const std::string&, Btype*, Location);
 191
 192   Btype*
 193   circular_pointer_type(Btype*, bool);
 194
 195   bool
 196   is_circular_pointer_type(Btype*);
 197
 198   // Expressions.
 199
 200   Bexpression*
 201   zero_expression(Btype*);
 202
 203   // Statements.
 204
 205   Bstatement*
 206   error_statement()
 207   { return this->make_statement(error_mark_node); }
 208
 209   Bstatement*
 210   expression_statement(Bexpression*);
 211
 212   Bstatement*
 213   init_statement(Bvariable* var, Bexpression* init);
 214
 215   Bstatement*
 216   assignment_statement(Bexpression* lhs, Bexpression* rhs, Location);
 217
 218   Bstatement*
 219   return_statement(Bfunction*, const std::vector<Bexpression*>&,
 220                    Location);
 221
 222   Bstatement*
 223   if_statement(Bexpression* condition, Bblock* then_block, Bblock* else_block,
 224                Location);
 225
 226   Bstatement*
 227   switch_statement(Bexpression* value,
 228                    const std::vector<std::vector<Bexpression*> >& cases,
 229                    const std::vector<Bstatement*>& statements,
 230                    Location);
 231
 232   Bstatement*
 233   compound_statement(Bstatement*, Bstatement*);
 234
 235   Bstatement*
 236   statement_list(const std::vector<Bstatement*>&);
 237
 238   // Blocks.
 239
 240   Bblock*
 241   block(Bfunction*, Bblock*, const std::vector<Bvariable*>&,
 242         Location, Location);
 243
 244   void
 245   block_add_statements(Bblock*, const std::vector<Bstatement*>&);
 246
 247   Bstatement*
 248   block_statement(Bblock*);
 249
 250   // Variables.
 251
 252   Bvariable*
 253   error_variable()
 254   { return new Bvariable(error_mark_node); }
 255
 256   Bvariable*
 257   global_variable(const std::string& package_name,
 258                   const std::string& unique_prefix,
 259                   const std::string& name,
 260                   Btype* btype,
 261                   bool is_external,
 262                   bool is_hidden,
 263                   Location location);
 264
 265   void
 266   global_variable_set_init(Bvariable*, Bexpression*);
 267
 268   Bvariable*
 269   local_variable(Bfunction*, const std::string&, Btype*, bool,
 270                  Location);
 271
 272   Bvariable*
 273   parameter_variable(Bfunction*, const std::string&, Btype*, bool,
 274                      Location);
 275
 276   Bvariable*
 277   temporary_variable(Bfunction*, Bblock*, Btype*, Bexpression*, bool,
 278                      Location, Bstatement**);
 279
 280   Bvariable*
 281   immutable_struct(const std::string&, bool, Btype*, Location);
 282
 283   void
 284   immutable_struct_set_init(Bvariable*, const std::string&, bool, Btype*,
 285                             Location, Bexpression*);
 286
 287   Bvariable*
 288   immutable_struct_reference(const std::string&, Btype*, Location);
 289
 290   // Labels.
 291
 292   Blabel*
 293   label(Bfunction*, const std::string& name, Location);
 294
 295   Bstatement*
 296   label_definition_statement(Blabel*);
 297
 298   Bstatement*
 299   goto_statement(Blabel*, Location);
 300
 301   Bexpression*
 302   label_address(Blabel*, Location);
 303
 304  private:
 305   // Make a Bexpression from a tree.
 306   Bexpression*
 307   make_expression(tree t)
 308   { return new Bexpression(t); }
 309
 310   // Make a Bstatement from a tree.
 311   Bstatement*
 312   make_statement(tree t)
 313   { return new Bstatement(t); }
 314
 315   // Make a Btype from a tree.
 316   Btype*
 317   make_type(tree t)
 318   { return new Btype(t); }
 319
 320   Btype*
 321   fill_in_struct(Btype*, const std::vector<Btyped_identifier>&);
 322
 323   Btype*
 324   fill_in_array(Btype*, Btype*, Bexpression*);
 325 };
 326
 327 // A helper function.
 328
 329 static inline tree
 330 get_identifier_from_string(const std::string& str)
 331 {
 332   return get_identifier_with_length(str.data(), str.length());
 333 }
 334
 335 // Get an unnamed integer type.
 336
 337 Btype*
 338 Gcc_backend::integer_type(bool is_unsigned, int bits)
 339 {
 340   tree type;
 341   if (is_unsigned)
 342     {
 343       if (bits == INT_TYPE_SIZE)
 344         type = unsigned_type_node;
 345       else if (bits == CHAR_TYPE_SIZE)
 346         type = unsigned_char_type_node;
 347       else if (bits == SHORT_TYPE_SIZE)
 348         type = short_unsigned_type_node;
 349       else if (bits == LONG_TYPE_SIZE)
 350         type = long_unsigned_type_node;
 351       else if (bits == LONG_LONG_TYPE_SIZE)
 352         type = long_long_unsigned_type_node;
 353       else
 354         type = make_unsigned_type(bits);
 355     }
 356   else
 357     {
 358       if (bits == INT_TYPE_SIZE)
 359         type = integer_type_node;
 360       else if (bits == CHAR_TYPE_SIZE)
 361         type = signed_char_type_node;
 362       else if (bits == SHORT_TYPE_SIZE)
 363         type = short_integer_type_node;
 364       else if (bits == LONG_TYPE_SIZE)
 365         type = long_integer_type_node;
 366       else if (bits == LONG_LONG_TYPE_SIZE)
 367         type = long_long_integer_type_node;
 368       else
 369         type = make_signed_type(bits);
 370     }
 371   return this->make_type(type);
 372 }
 373
 374 // Get an unnamed float type.
 375
 376 Btype*
 377 Gcc_backend::float_type(int bits)
 378 {
 379   tree type;
 380   if (bits == FLOAT_TYPE_SIZE)
 381     type = float_type_node;
 382   else if (bits == DOUBLE_TYPE_SIZE)
 383     type = double_type_node;
 384   else if (bits == LONG_DOUBLE_TYPE_SIZE)
 385     type = long_double_type_node;
 386   else
 387     {
 388       type = make_node(REAL_TYPE);
 389       TYPE_PRECISION(type) = bits;
 390       layout_type(type);
 391     }
 392   return this->make_type(type);
 393 }
 394
 395 // Get an unnamed complex type.
 396
 397 Btype*
 398 Gcc_backend::complex_type(int bits)
 399 {
 400   tree type;
 401   if (bits == FLOAT_TYPE_SIZE * 2)
 402     type = complex_float_type_node;
 403   else if (bits == DOUBLE_TYPE_SIZE * 2)
 404     type = complex_double_type_node;
 405   else if (bits == LONG_DOUBLE_TYPE_SIZE * 2)
 406     type = complex_long_double_type_node;
 407   else
 408     {
 409       type = make_node(REAL_TYPE);
 410       TYPE_PRECISION(type) = bits / 2;
 411       layout_type(type);
 412       type = build_complex_type(type);
 413     }
 414   return this->make_type(type);
 415 }
 416
 417 // Get a pointer type.
 418
 419 Btype*
 420 Gcc_backend::pointer_type(Btype* to_type)
 421 {
 422   tree to_type_tree = to_type->get_tree();
 423   if (to_type_tree == error_mark_node)
 424     return this->error_type();
 425   tree type = build_pointer_type(to_type_tree);
 426   return this->make_type(type);
 427 }
 428
 429 // Make a function type.
 430
 431 Btype*
 432 Gcc_backend::function_type(const Btyped_identifier& receiver,
 433                            const std::vector<Btyped_identifier>& parameters,
 434                            const std::vector<Btyped_identifier>& results,
 435                            Location location)
 436 {
 437   tree args = NULL_TREE;
 438   tree* pp = &args;
 439   if (receiver.btype != NULL)
 440     {
 441       tree t = receiver.btype->get_tree();
 442       if (t == error_mark_node)
 443         return this->error_type();
 444       *pp = tree_cons(NULL_TREE, t, NULL_TREE);
 445       pp = &TREE_CHAIN(*pp);
 446     }
 447
 448   for (std::vector<Btyped_identifier>::const_iterator p = parameters.begin();
 449        p != parameters.end();
 450        ++p)
 451     {
 452       tree t = p->btype->get_tree();
 453       if (t == error_mark_node)
 454         return this->error_type();
 455       *pp = tree_cons(NULL_TREE, t, NULL_TREE);
 456       pp = &TREE_CHAIN(*pp);
 457     }
 458
 459   // Varargs is handled entirely at the Go level.  When converted to
 460   // GENERIC functions are not varargs.
 461   *pp = void_list_node;
 462
 463   tree result;
 464   if (results.empty())
 465     result = void_type_node;
 466   else if (results.size() == 1)
 467     result = results.front().btype->get_tree();
 468   else
 469     {
 470       result = make_node(RECORD_TYPE);
 471       tree field_trees = NULL_TREE;
 472       pp = &field_trees;
 473       for (std::vector<Btyped_identifier>::const_iterator p = results.begin();
 474            p != results.end();
 475            ++p)
 476         {
 477           const std::string name = (p->name.empty()
 478                                     ? "UNNAMED"
 479                                     : p->name);
 480           tree name_tree = get_identifier_from_string(name);
 481           tree field_type_tree = p->btype->get_tree();
 482           if (field_type_tree == error_mark_node)
 483             return this->error_type();
 484           gcc_assert(TYPE_SIZE(field_type_tree) != NULL_TREE);
 485           tree field = build_decl(location.gcc_location(), FIELD_DECL,
 486                                   name_tree, field_type_tree);
 487           DECL_CONTEXT(field) = result;
 488           *pp = field;
 489           pp = &DECL_CHAIN(field);
 490         }
 491       TYPE_FIELDS(result) = field_trees;
 492       layout_type(result);
 493     }
 494   if (result == error_mark_node)
 495     return this->error_type();
 496
 497   tree fntype = build_function_type(result, args);
 498   if (fntype == error_mark_node)
 499     return this->error_type();
 500
 501   return this->make_type(build_pointer_type(fntype));
 502 }
 503
 504 // Make a struct type.
 505
 506 Btype*
 507 Gcc_backend::struct_type(const std::vector<Btyped_identifier>& fields)
 508 {
 509   return this->fill_in_struct(this->make_type(make_node(RECORD_TYPE)), fields);
 510 }
 511
 512 // Fill in the fields of a struct type.
 513
 514 Btype*
 515 Gcc_backend::fill_in_struct(Btype* fill,
 516                             const std::vector<Btyped_identifier>& fields)
 517 {
 518   tree fill_tree = fill->get_tree();
 519   tree field_trees = NULL_TREE;
 520   tree* pp = &field_trees;
 521   for (std::vector<Btyped_identifier>::const_iterator p = fields.begin();
 522        p != fields.end();
 523        ++p)
 524     {
 525       tree name_tree = get_identifier_from_string(p->name);
 526       tree type_tree = p->btype->get_tree();
 527       if (type_tree == error_mark_node)
 528         return this->error_type();
 529       tree field = build_decl(p->location.gcc_location(), FIELD_DECL, name_tree,
 530                               type_tree);
 531       DECL_CONTEXT(field) = fill_tree;
 532       *pp = field;
 533       pp = &DECL_CHAIN(field);
 534     }
 535   TYPE_FIELDS(fill_tree) = field_trees;
 536   layout_type(fill_tree);
 537   return fill;
 538 }
 539
 540 // Make an array type.
 541
 542 Btype*
 543 Gcc_backend::array_type(Btype* element_btype, Bexpression* length)
 544 {
 545   return this->fill_in_array(this->make_type(make_node(ARRAY_TYPE)),
 546                              element_btype, length);
 547 }
 548
 549 // Fill in an array type.
 550
 551 Btype*
 552 Gcc_backend::fill_in_array(Btype* fill, Btype* element_type,
 553                            Bexpression* length)
 554 {
 555   tree element_type_tree = element_type->get_tree();
 556   tree length_tree = length->get_tree();
 557   if (element_type_tree == error_mark_node || length_tree == error_mark_node)
 558     return this->error_type();
 559
 560   gcc_assert(TYPE_SIZE(element_type_tree) != NULL_TREE);
 561
 562   length_tree = fold_convert(sizetype, length_tree);
 563
 564   // build_index_type takes the maximum index, which is one less than
 565   // the length.
 566   tree index_type_tree = build_index_type(fold_build2(MINUS_EXPR, sizetype,
 567                                                       length_tree,
 568                                                       size_one_node));
 569
 570   tree fill_tree = fill->get_tree();
 571   TREE_TYPE(fill_tree) = element_type_tree;
 572   TYPE_DOMAIN(fill_tree) = index_type_tree;
 573   TYPE_ADDR_SPACE(fill_tree) = TYPE_ADDR_SPACE(element_type_tree);
 574   layout_type(fill_tree);
 575
 576   if (TYPE_STRUCTURAL_EQUALITY_P(element_type_tree))
 577     SET_TYPE_STRUCTURAL_EQUALITY(fill_tree);
 578   else if (TYPE_CANONICAL(element_type_tree) != element_type_tree
 579            || TYPE_CANONICAL(index_type_tree) != index_type_tree)
 580     TYPE_CANONICAL(fill_tree) =
 581       build_array_type(TYPE_CANONICAL(element_type_tree),
 582                        TYPE_CANONICAL(index_type_tree));
 583
 584   return fill;
 585 }
 586
 587 // Create a placeholder for a pointer type.
 588
 589 Btype*
 590 Gcc_backend::placeholder_pointer_type(const std::string& name,
 591                                       Location location, bool)
 592 {
 593   tree ret = build_variant_type_copy(ptr_type_node);
 594   if (!name.empty())
 595     {
 596       tree decl = build_decl(location.gcc_location(), TYPE_DECL,
 597                              get_identifier_from_string(name),
 598                              ret);
 599       TYPE_NAME(ret) = decl;
 600     }
 601   return this->make_type(ret);
 602 }
 603
 604 // Set the real target type for a placeholder pointer type.
 605
 606 bool
 607 Gcc_backend::set_placeholder_pointer_type(Btype* placeholder,
 608                                           Btype* to_type)
 609 {
 610   tree pt = placeholder->get_tree();
 611   if (pt == error_mark_node)
 612     return false;
 613   gcc_assert(TREE_CODE(pt) == POINTER_TYPE);
 614   tree tt = to_type->get_tree();
 615   if (tt == error_mark_node)
 616     {
 617       TREE_TYPE(pt) = tt;
 618       return false;
 619     }
 620   gcc_assert(TREE_CODE(tt) == POINTER_TYPE);
 621   TREE_TYPE(pt) = TREE_TYPE(tt);
 622   if (TYPE_NAME(pt) != NULL_TREE)
 623     {
 624       // Build the data structure gcc wants to see for a typedef.
 625       tree copy = build_variant_type_copy(pt);
 626       TYPE_NAME(copy) = NULL_TREE;
 627       DECL_ORIGINAL_TYPE(TYPE_NAME(pt)) = copy;
 628     }
 629   return true;
 630 }
 631
 632 // Set the real values for a placeholder function type.
 633
 634 bool
 635 Gcc_backend::set_placeholder_function_type(Btype* placeholder, Btype* ft)
 636 {
 637   return this->set_placeholder_pointer_type(placeholder, ft);
 638 }
 639
 640 // Create a placeholder for a struct type.
 641
 642 Btype*
 643 Gcc_backend::placeholder_struct_type(const std::string& name,
 644                                      Location location)
 645 {
 646   tree ret = make_node(RECORD_TYPE);
 647   tree decl = build_decl(location.gcc_location(), TYPE_DECL,
 648                          get_identifier_from_string(name),
 649                          ret);
 650   TYPE_NAME(ret) = decl;
 651   return this->make_type(ret);
 652 }
 653
 654 // Fill in the fields of a placeholder struct type.
 655
 656 bool
 657 Gcc_backend::set_placeholder_struct_type(
 658     Btype* placeholder,
 659     const std::vector<Btyped_identifier>& fields)
 660 {
 661   tree t = placeholder->get_tree();
 662   gcc_assert(TREE_CODE(t) == RECORD_TYPE && TYPE_FIELDS(t) == NULL_TREE);
 663   Btype* r = this->fill_in_struct(placeholder, fields);
 664
 665   // Build the data structure gcc wants to see for a typedef.
 666   tree copy = build_distinct_type_copy(t);
 667   TYPE_NAME(copy) = NULL_TREE;
 668   DECL_ORIGINAL_TYPE(TYPE_NAME(t)) = copy;
 669
 670   return r->get_tree() != error_mark_node;
 671 }
 672
 673 // Create a placeholder for an array type.
 674
 675 Btype*
 676 Gcc_backend::placeholder_array_type(const std::string& name,
 677                                     Location location)
 678 {
 679   tree ret = make_node(ARRAY_TYPE);
 680   tree decl = build_decl(location.gcc_location(), TYPE_DECL,
 681                          get_identifier_from_string(name),
 682                          ret);
 683   TYPE_NAME(ret) = decl;
 684   return this->make_type(ret);
 685 }
 686
 687 // Fill in the fields of a placeholder array type.
 688
 689 bool
 690 Gcc_backend::set_placeholder_array_type(Btype* placeholder,
 691                                         Btype* element_btype,
 692                                         Bexpression* length)
 693 {
 694   tree t = placeholder->get_tree();
 695   gcc_assert(TREE_CODE(t) == ARRAY_TYPE && TREE_TYPE(t) == NULL_TREE);
 696   Btype* r = this->fill_in_array(placeholder, element_btype, length);
 697
 698   // Build the data structure gcc wants to see for a typedef.
 699   tree copy = build_distinct_type_copy(t);
 700   TYPE_NAME(copy) = NULL_TREE;
 701   DECL_ORIGINAL_TYPE(TYPE_NAME(t)) = copy;
 702
 703   return r->get_tree() != error_mark_node;
 704 }
 705
 706 // Return a named version of a type.
 707
 708 Btype*
 709 Gcc_backend::named_type(const std::string& name, Btype* btype,
 710                         Location location)
 711 {
 712   tree type = btype->get_tree();
 713   if (type == error_mark_node)
 714     return this->error_type();
 715
 716   // The middle-end expects a basic type to have a name.  In Go every
 717   // basic type will have a name.  The first time we see a basic type,
 718   // give it whatever Go name we have at this point.
 719   if (TYPE_NAME(type) == NULL_TREE
 720       && location.gcc_location() == BUILTINS_LOCATION
 721       && (TREE_CODE(type) == INTEGER_TYPE
 722           || TREE_CODE(type) == REAL_TYPE
 723           || TREE_CODE(type) == COMPLEX_TYPE
 724           || TREE_CODE(type) == BOOLEAN_TYPE))
 725     {
 726       tree decl = build_decl(BUILTINS_LOCATION, TYPE_DECL,
 727                              get_identifier_from_string(name),
 728                              type);
 729       TYPE_NAME(type) = decl;
 730       return this->make_type(type);
 731     }
 732
 733   tree copy = build_variant_type_copy(type);
 734   tree decl = build_decl(location.gcc_location(), TYPE_DECL,
 735                          get_identifier_from_string(name),
 736                          copy);
 737   DECL_ORIGINAL_TYPE(decl) = type;
 738   TYPE_NAME(copy) = decl;
 739   return this->make_type(copy);
 740 }
 741
 742 // Return a pointer type used as a marker for a circular type.
 743
 744 Btype*
 745 Gcc_backend::circular_pointer_type(Btype*, bool)
 746 {
 747   return this->make_type(ptr_type_node);
 748 }
 749
 750 // Return whether we might be looking at a circular type.
 751
 752 bool
 753 Gcc_backend::is_circular_pointer_type(Btype* btype)
 754 {
 755   return btype->get_tree() == ptr_type_node;
 756 }
 757
 758 // Return the zero value for a type.
 759
 760 Bexpression*
 761 Gcc_backend::zero_expression(Btype* btype)
 762 {
 763   tree t = btype->get_tree();
 764   tree ret;
 765   if (t == error_mark_node)
 766     ret = error_mark_node;
 767   else
 768     ret = build_zero_cst(t);
 769   return tree_to_expr(ret);
 770 }
 771
 772 // An expression as a statement.
 773
 774 Bstatement*
 775 Gcc_backend::expression_statement(Bexpression* expr)
 776 {
 777   return this->make_statement(expr->get_tree());
 778 }
 779
 780 // Variable initialization.
 781
 782 Bstatement*
 783 Gcc_backend::init_statement(Bvariable* var, Bexpression* init)
 784 {
 785   tree var_tree = var->get_tree();
 786   tree init_tree = init->get_tree();
 787   if (var_tree == error_mark_node || init_tree == error_mark_node)
 788     return this->error_statement();
 789   gcc_assert(TREE_CODE(var_tree) == VAR_DECL);
 790   DECL_INITIAL(var_tree) = init_tree;
 791   return this->make_statement(build1_loc(DECL_SOURCE_LOCATION(var_tree),
 792                                          DECL_EXPR, void_type_node, var_tree));
 793 }
 794
 795 // Assignment.
 796
 797 Bstatement*
 798 Gcc_backend::assignment_statement(Bexpression* lhs, Bexpression* rhs,
 799                                   Location location)
 800 {
 801   tree lhs_tree = lhs->get_tree();
 802   tree rhs_tree = rhs->get_tree();
 803   if (lhs_tree == error_mark_node || rhs_tree == error_mark_node)
 804     return this->error_statement();
 805   return this->make_statement(fold_build2_loc(location.gcc_location(),
 806                                               MODIFY_EXPR,
 807                                               void_type_node,
 808                                               lhs_tree, rhs_tree));
 809 }
 810
 811 // Return.
 812
 813 Bstatement*
 814 Gcc_backend::return_statement(Bfunction* bfunction,
 815                               const std::vector<Bexpression*>& vals,
 816                               Location location)
 817 {
 818   tree fntree = bfunction->get_tree();
 819   if (fntree == error_mark_node)
 820     return this->error_statement();
 821   tree result = DECL_RESULT(fntree);
 822   if (result == error_mark_node)
 823     return this->error_statement();
 824   tree ret;
 825   if (vals.empty())
 826     ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR, void_type_node,
 827                           NULL_TREE);
 828   else if (vals.size() == 1)
 829     {
 830       tree val = vals.front()->get_tree();
 831       if (val == error_mark_node)
 832         return this->error_statement();
 833       tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
 834                                  void_type_node, result,
 835                                  vals.front()->get_tree());
 836       ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
 837                             void_type_node, set);
 838     }
 839   else
 840     {
 841       // To return multiple values, copy the values into a temporary
 842       // variable of the right structure type, and then assign the
 843       // temporary variable to the DECL_RESULT in the return
 844       // statement.
 845       tree stmt_list = NULL_TREE;
 846       tree rettype = TREE_TYPE(result);
 847       tree rettmp = create_tmp_var(rettype, "RESULT");
 848       tree field = TYPE_FIELDS(rettype);
 849       for (std::vector<Bexpression*>::const_iterator p = vals.begin();
 850            p != vals.end();
 851            p++, field = DECL_CHAIN(field))
 852         {
 853           gcc_assert(field != NULL_TREE);
 854           tree ref = fold_build3_loc(location.gcc_location(), COMPONENT_REF,
 855                                      TREE_TYPE(field), rettmp, field,
 856                                      NULL_TREE);
 857           tree val = (*p)->get_tree();
 858           if (val == error_mark_node)
 859             return this->error_statement();
 860           tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
 861                                      void_type_node,
 862                                      ref, (*p)->get_tree());
 863           append_to_statement_list(set, &stmt_list);
 864         }
 865       gcc_assert(field == NULL_TREE);
 866       tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
 867                                  void_type_node,
 868                                  result, rettmp);
 869       tree ret_expr = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
 870                                       void_type_node, set);
 871       append_to_statement_list(ret_expr, &stmt_list);
 872       ret = stmt_list;
 873     }
 874   return this->make_statement(ret);
 875 }
 876
 877 // If.
 878
 879 Bstatement*
 880 Gcc_backend::if_statement(Bexpression* condition, Bblock* then_block,
 881                           Bblock* else_block, Location location)
 882 {
 883   tree cond_tree = condition->get_tree();
 884   tree then_tree = then_block->get_tree();
 885   tree else_tree = else_block == NULL ? NULL_TREE : else_block->get_tree();
 886   if (cond_tree == error_mark_node
 887       || then_tree == error_mark_node
 888       || else_tree == error_mark_node)
 889     return this->error_statement();
 890   tree ret = build3_loc(location.gcc_location(), COND_EXPR, void_type_node,
 891                         cond_tree, then_tree, else_tree);
 892   return this->make_statement(ret);
 893 }
 894
 895 // Switch.
 896
 897 Bstatement*
 898 Gcc_backend::switch_statement(
 899     Bexpression* value,
 900     const std::vector<std::vector<Bexpression*> >& cases,
 901     const std::vector<Bstatement*>& statements,
 902     Location switch_location)
 903 {
 904   gcc_assert(cases.size() == statements.size());
 905
 906   tree stmt_list = NULL_TREE;
 907   std::vector<std::vector<Bexpression*> >::const_iterator pc = cases.begin();
 908   for (std::vector<Bstatement*>::const_iterator ps = statements.begin();
 909        ps != statements.end();
 910        ++ps, ++pc)
 911     {
 912       if (pc->empty())
 913         {
 914           source_location loc = (*ps != NULL
 915                                  ? EXPR_LOCATION((*ps)->get_tree())
 916                                  : UNKNOWN_LOCATION);
 917           tree label = create_artificial_label(loc);
 918           tree c = build_case_label(NULL_TREE, NULL_TREE, label);
 919           append_to_statement_list(c, &stmt_list);
 920         }
 921       else
 922         {
 923           for (std::vector<Bexpression*>::const_iterator pcv = pc->begin();
 924                pcv != pc->end();
 925                ++pcv)
 926             {
 927               tree t = (*pcv)->get_tree();
 928               if (t == error_mark_node)
 929                 return this->error_statement();
 930               source_location loc = EXPR_LOCATION(t);
 931               tree label = create_artificial_label(loc);
 932               tree c = build_case_label((*pcv)->get_tree(), NULL_TREE, label);
 933               append_to_statement_list(c, &stmt_list);
 934             }
 935         }
 936
 937       if (*ps != NULL)
 938         {
 939           tree t = (*ps)->get_tree();
 940           if (t == error_mark_node)
 941             return this->error_statement();
 942           append_to_statement_list(t, &stmt_list);
 943         }
 944     }
 945
 946   tree tv = value->get_tree();
 947   if (tv == error_mark_node)
 948     return this->error_statement();
 949   tree t = build3_loc(switch_location.gcc_location(), SWITCH_EXPR,
 950                       void_type_node, tv, stmt_list, NULL_TREE);
 951   return this->make_statement(t);
 952 }
 953
 954 // Pair of statements.
 955
 956 Bstatement*
 957 Gcc_backend::compound_statement(Bstatement* s1, Bstatement* s2)
 958 {
 959   tree stmt_list = NULL_TREE;
 960   tree t = s1->get_tree();
 961   if (t == error_mark_node)
 962     return this->error_statement();
 963   append_to_statement_list(t, &stmt_list);
 964   t = s2->get_tree();
 965   if (t == error_mark_node)
 966     return this->error_statement();
 967   append_to_statement_list(t, &stmt_list);
 968   return this->make_statement(stmt_list);
 969 }
 970
 971 // List of statements.
 972
 973 Bstatement*
 974 Gcc_backend::statement_list(const std::vector<Bstatement*>& statements)
 975 {
 976   tree stmt_list = NULL_TREE;
 977   for (std::vector<Bstatement*>::const_iterator p = statements.begin();
 978        p != statements.end();
 979        ++p)
 980     {
 981       tree t = (*p)->get_tree();
 982       if (t == error_mark_node)
 983         return this->error_statement();
 984       append_to_statement_list(t, &stmt_list);
 985     }
 986   return this->make_statement(stmt_list);
 987 }
 988
 989 // Make a block.  For some reason gcc uses a dual structure for
 990 // blocks: BLOCK tree nodes and BIND_EXPR tree nodes.  Since the
 991 // BIND_EXPR node points to the BLOCK node, we store the BIND_EXPR in
 992 // the Bblock.
 993
 994 Bblock*
 995 Gcc_backend::block(Bfunction* function, Bblock* enclosing,
 996                    const std::vector<Bvariable*>& vars,
 997                    Location start_location,
 998                    Location)
 999 {
1000   tree block_tree = make_node(BLOCK);
1001   if (enclosing == NULL)
1002     {
1003       // FIXME: Permitting FUNCTION to be NULL is a temporary measure
1004       // until we have a proper representation of the init function.
1005       tree fndecl;
1006       if (function == NULL)
1007         fndecl = current_function_decl;
1008       else
1009         fndecl = function->get_tree();
1010       gcc_assert(fndecl != NULL_TREE);
1011
1012       // We may have already created a block for local variables when
1013       // we take the address of a parameter.
1014       if (DECL_INITIAL(fndecl) == NULL_TREE)
1015         {
1016           BLOCK_SUPERCONTEXT(block_tree) = fndecl;
1017           DECL_INITIAL(fndecl) = block_tree;
1018         }
1019       else
1020         {
1021           tree superblock_tree = DECL_INITIAL(fndecl);
1022           BLOCK_SUPERCONTEXT(block_tree) = superblock_tree;
1023           tree* pp;
1024           for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
1025                *pp != NULL_TREE;
1026                pp = &BLOCK_CHAIN(*pp))
1027             ;
1028           *pp = block_tree;
1029         }
1030     }
1031   else
1032     {
1033       tree superbind_tree = enclosing->get_tree();
1034       tree superblock_tree = BIND_EXPR_BLOCK(superbind_tree);
1035       gcc_assert(TREE_CODE(superblock_tree) == BLOCK);
1036
1037       BLOCK_SUPERCONTEXT(block_tree) = superblock_tree;
1038       tree* pp;
1039       for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
1040            *pp != NULL_TREE;
1041            pp = &BLOCK_CHAIN(*pp))
1042         ;
1043       *pp = block_tree;
1044     }
1045
1046   tree* pp = &BLOCK_VARS(block_tree);
1047   for (std::vector<Bvariable*>::const_iterator pv = vars.begin();
1048        pv != vars.end();
1049        ++pv)
1050     {
1051       *pp = (*pv)->get_tree();
1052       if (*pp != error_mark_node)
1053         pp = &DECL_CHAIN(*pp);
1054     }
1055   *pp = NULL_TREE;
1056
1057   TREE_USED(block_tree) = 1;
1058
1059   tree bind_tree = build3_loc(start_location.gcc_location(), BIND_EXPR,
1060                               void_type_node, BLOCK_VARS(block_tree),
1061                               NULL_TREE, block_tree);
1062   TREE_SIDE_EFFECTS(bind_tree) = 1;
1063
1064   return new Bblock(bind_tree);
1065 }
1066
1067 // Add statements to a block.
1068
1069 void
1070 Gcc_backend::block_add_statements(Bblock* bblock,
1071                                   const std::vector<Bstatement*>& statements)
1072 {
1073   tree stmt_list = NULL_TREE;
1074   for (std::vector<Bstatement*>::const_iterator p = statements.begin();
1075        p != statements.end();
1076        ++p)
1077     {
1078       tree s = (*p)->get_tree();
1079       if (s != error_mark_node)
1080         append_to_statement_list(s, &stmt_list);
1081     }
1082
1083   tree bind_tree = bblock->get_tree();
1084   gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
1085   BIND_EXPR_BODY(bind_tree) = stmt_list;
1086 }
1087
1088 // Return a block as a statement.
1089
1090 Bstatement*
1091 Gcc_backend::block_statement(Bblock* bblock)
1092 {
1093   tree bind_tree = bblock->get_tree();
1094   gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
1095   return this->make_statement(bind_tree);
1096 }
1097
1098 // Make a global variable.
1099
1100 Bvariable*
1101 Gcc_backend::global_variable(const std::string& package_name,
1102                              const std::string& unique_prefix,
1103                              const std::string& name,
1104                              Btype* btype,
1105                              bool is_external,
1106                              bool is_hidden,
1107                              Location location)
1108 {
1109   tree type_tree = btype->get_tree();
1110   if (type_tree == error_mark_node)
1111     return this->error_variable();
1112
1113   std::string var_name(package_name);
1114   var_name.push_back('.');
1115   var_name.append(name);
1116   tree decl = build_decl(location.gcc_location(), VAR_DECL,
1117                          get_identifier_from_string(var_name),
1118                          type_tree);
1119   if (is_external)
1120     DECL_EXTERNAL(decl) = 1;
1121   else
1122     TREE_STATIC(decl) = 1;
1123   if (!is_hidden)
1124     {
1125       TREE_PUBLIC(decl) = 1;
1126
1127       std::string asm_name(unique_prefix);
1128       asm_name.push_back('.');
1129       asm_name.append(var_name);
1130       SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
1131     }
1132   TREE_USED(decl) = 1;
1133
1134   go_preserve_from_gc(decl);
1135
1136   return new Bvariable(decl);
1137 }
1138
1139 // Set the initial value of a global variable.
1140
1141 void
1142 Gcc_backend::global_variable_set_init(Bvariable* var, Bexpression* expr)
1143 {
1144   tree expr_tree = expr->get_tree();
1145   if (expr_tree == error_mark_node)
1146     return;
1147   gcc_assert(TREE_CONSTANT(expr_tree));
1148   tree var_decl = var->get_tree();
1149   if (var_decl == error_mark_node)
1150     return;
1151   DECL_INITIAL(var_decl) = expr_tree;
1152 }
1153
1154 // Make a local variable.
1155
1156 Bvariable*
1157 Gcc_backend::local_variable(Bfunction* function, const std::string& name,
1158                             Btype* btype, bool is_address_taken,
1159                             Location location)
1160 {
1161   tree type_tree = btype->get_tree();
1162   if (type_tree == error_mark_node)
1163     return this->error_variable();
1164   tree decl = build_decl(location.gcc_location(), VAR_DECL,
1165                          get_identifier_from_string(name),
1166                          type_tree);
1167   DECL_CONTEXT(decl) = function->get_tree();
1168   TREE_USED(decl) = 1;
1169   if (is_address_taken)
1170     TREE_ADDRESSABLE(decl) = 1;
1171   go_preserve_from_gc(decl);
1172   return new Bvariable(decl);
1173 }
1174
1175 // Make a function parameter variable.
1176
1177 Bvariable*
1178 Gcc_backend::parameter_variable(Bfunction* function, const std::string& name,
1179                                 Btype* btype, bool is_address_taken,
1180                                 Location location)
1181 {
1182   tree type_tree = btype->get_tree();
1183   if (type_tree == error_mark_node)
1184     return this->error_variable();
1185   tree decl = build_decl(location.gcc_location(), PARM_DECL,
1186                          get_identifier_from_string(name),
1187                          type_tree);
1188   DECL_CONTEXT(decl) = function->get_tree();
1189   DECL_ARG_TYPE(decl) = type_tree;
1190   TREE_USED(decl) = 1;
1191   if (is_address_taken)
1192     TREE_ADDRESSABLE(decl) = 1;
1193   go_preserve_from_gc(decl);
1194   return new Bvariable(decl);
1195 }
1196
1197 // Make a temporary variable.
1198
1199 Bvariable*
1200 Gcc_backend::temporary_variable(Bfunction* function, Bblock* bblock,
1201                                 Btype* btype, Bexpression* binit,
1202                                 bool is_address_taken,
1203                                 Location location,
1204                                 Bstatement** pstatement)
1205 {
1206   tree type_tree = btype->get_tree();
1207   tree init_tree = binit == NULL ? NULL_TREE : binit->get_tree();
1208   if (type_tree == error_mark_node || init_tree == error_mark_node)
1209     {
1210       *pstatement = this->error_statement();
1211       return this->error_variable();
1212     }
1213
1214   tree var;
1215   // We can only use create_tmp_var if the type is not addressable.
1216   if (!TREE_ADDRESSABLE(type_tree))
1217     var = create_tmp_var(type_tree, "GOTMP");
1218   else
1219     {
1220       gcc_assert(bblock != NULL);
1221       var = build_decl(location.gcc_location(), VAR_DECL,
1222                        create_tmp_var_name("GOTMP"),
1223                        type_tree);
1224       DECL_ARTIFICIAL(var) = 1;
1225       DECL_IGNORED_P(var) = 1;
1226       TREE_USED(var) = 1;
1227       // FIXME: Permitting function to be NULL here is a temporary
1228       // measure until we have a proper representation of the init
1229       // function.
1230       if (function != NULL)
1231         DECL_CONTEXT(var) = function->get_tree();
1232       else
1233         {
1234           gcc_assert(current_function_decl != NULL_TREE);
1235           DECL_CONTEXT(var) = current_function_decl;
1236         }
1237
1238       // We have to add this variable to the BLOCK and the BIND_EXPR.
1239       tree bind_tree = bblock->get_tree();
1240       gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
1241       tree block_tree = BIND_EXPR_BLOCK(bind_tree);
1242       gcc_assert(TREE_CODE(block_tree) == BLOCK);
1243       DECL_CHAIN(var) = BLOCK_VARS(block_tree);
1244       BLOCK_VARS(block_tree) = var;
1245       BIND_EXPR_VARS(bind_tree) = BLOCK_VARS(block_tree);
1246     }
1247
1248   if (init_tree != NULL_TREE)
1249     DECL_INITIAL(var) = fold_convert_loc(location.gcc_location(), type_tree,
1250                                          init_tree);
1251
1252   if (is_address_taken)
1253     TREE_ADDRESSABLE(var) = 1;
1254
1255   *pstatement = this->make_statement(build1_loc(location.gcc_location(),
1256                                                 DECL_EXPR,
1257                                                 void_type_node, var));
1258   return new Bvariable(var);
1259 }
1260
1261 // Create a named immutable initialized data structure.
1262
1263 Bvariable*
1264 Gcc_backend::immutable_struct(const std::string& name, bool, Btype* btype,
1265                               Location location)
1266 {
1267   tree type_tree = btype->get_tree();
1268   if (type_tree == error_mark_node)
1269     return this->error_variable();
1270   gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
1271   tree decl = build_decl(location.gcc_location(), VAR_DECL,
1272                          get_identifier_from_string(name),
1273                          build_qualified_type(type_tree, TYPE_QUAL_CONST));
1274   TREE_STATIC(decl) = 1;
1275   TREE_READONLY(decl) = 1;
1276   TREE_CONSTANT(decl) = 1;
1277   TREE_USED(decl) = 1;
1278   DECL_ARTIFICIAL(decl) = 1;
1279
1280   // We don't call rest_of_decl_compilation until we have the
1281   // initializer.
1282
1283   go_preserve_from_gc(decl);
1284   return new Bvariable(decl);
1285 }
1286
1287 // Set the initializer for a variable created by immutable_struct.
1288 // This is where we finish compiling the variable.
1289
1290 void
1291 Gcc_backend::immutable_struct_set_init(Bvariable* var, const std::string&,
1292                                        bool is_common, Btype*,
1293                                        Location,
1294                                        Bexpression* initializer)
1295 {
1296   tree decl = var->get_tree();
1297   tree init_tree = initializer->get_tree();
1298   if (decl == error_mark_node || init_tree == error_mark_node)
1299     return;
1300
1301   DECL_INITIAL(decl) = init_tree;
1302
1303   // We can't call make_decl_one_only until we set DECL_INITIAL.
1304   if (!is_common)
1305     TREE_PUBLIC(decl) = 1;
1306   else
1307     {
1308       make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
1309       resolve_unique_section(decl, 1, 0);
1310     }
1311
1312   rest_of_decl_compilation(decl, 1, 0);
1313 }
1314
1315 // Return a reference to an immutable initialized data structure
1316 // defined in another package.
1317
1318 Bvariable*
1319 Gcc_backend::immutable_struct_reference(const std::string& name, Btype* btype,
1320                                         Location location)
1321 {
1322   tree type_tree = btype->get_tree();
1323   if (type_tree == error_mark_node)
1324     return this->error_variable();
1325   gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
1326   tree decl = build_decl(location.gcc_location(), VAR_DECL,
1327                          get_identifier_from_string(name),
1328                          build_qualified_type(type_tree, TYPE_QUAL_CONST));
1329   TREE_READONLY(decl) = 1;
1330   TREE_CONSTANT(decl) = 1;
1331   DECL_ARTIFICIAL(decl) = 1;
1332   TREE_PUBLIC(decl) = 1;
1333   DECL_EXTERNAL(decl) = 1;
1334   go_preserve_from_gc(decl);
1335   return new Bvariable(decl);
1336 }
1337
1338 // Make a label.
1339
1340 Blabel*
1341 Gcc_backend::label(Bfunction* function, const std::string& name,
1342                    Location location)
1343 {
1344   tree decl;
1345   if (name.empty())
1346     decl = create_artificial_label(location.gcc_location());
1347   else
1348     {
1349       tree id = get_identifier_from_string(name);
1350       decl = build_decl(location.gcc_location(), LABEL_DECL, id,
1351                         void_type_node);
1352       DECL_CONTEXT(decl) = function->get_tree();
1353     }
1354   return new Blabel(decl);
1355 }
1356
1357 // Make a statement which defines a label.
1358
1359 Bstatement*
1360 Gcc_backend::label_definition_statement(Blabel* label)
1361 {
1362   tree lab = label->get_tree();
1363   tree ret = fold_build1_loc(DECL_SOURCE_LOCATION(lab), LABEL_EXPR,
1364                              void_type_node, lab);
1365   return this->make_statement(ret);
1366 }
1367
1368 // Make a goto statement.
1369
1370 Bstatement*
1371 Gcc_backend::goto_statement(Blabel* label, Location location)
1372 {
1373   tree lab = label->get_tree();
1374   tree ret = fold_build1_loc(location.gcc_location(), GOTO_EXPR, void_type_node,
1375                              lab);
1376   return this->make_statement(ret);
1377 }
1378
1379 // Get the address of a label.
1380
1381 Bexpression*
1382 Gcc_backend::label_address(Blabel* label, Location location)
1383 {
1384   tree lab = label->get_tree();
1385   TREE_USED(lab) = 1;
1386   TREE_ADDRESSABLE(lab) = 1;
1387   tree ret = fold_convert_loc(location.gcc_location(), ptr_type_node,
1388                               build_fold_addr_expr_loc(location.gcc_location(),
1389                                                        lab));
1390   return this->make_expression(ret);
1391 }
1392
1393 // The single backend.
1394
1395 static Gcc_backend gcc_backend;
1396
1397 // Return the backend generator.
1398
1399 Backend*
1400 go_get_backend()
1401 {
1402   return &gcc_backend;
1403 }
1404
1405 // FIXME: Temporary functions while converting to the new backend
1406 // interface.
1407
1408 Btype*
1409 tree_to_type(tree t)
1410 {
1411   return new Btype(t);
1412 }
1413
1414 Bexpression*
1415 tree_to_expr(tree t)
1416 {
1417   return new Bexpression(t);
1418 }
1419
1420 Bstatement*
1421 tree_to_stat(tree t)
1422 {
1423   return new Bstatement(t);
1424 }
1425
1426 Bfunction*
1427 tree_to_function(tree t)
1428 {
1429   return new Bfunction(t);
1430 }
1431
1432 Bblock*
1433 tree_to_block(tree t)
1434 {
1435   gcc_assert(TREE_CODE(t) == BIND_EXPR);
1436   return new Bblock(t);
1437 }
1438
1439 tree
1440 type_to_tree(Btype* bt)
1441 {
1442   return bt->get_tree();
1443 }
1444
1445 tree
1446 expr_to_tree(Bexpression* be)
1447 {
1448   return be->get_tree();
1449 }
1450
1451 tree
1452 stat_to_tree(Bstatement* bs)
1453 {
1454   return bs->get_tree();
1455 }
1456
1457 tree
1458 block_to_tree(Bblock* bb)
1459 {
1460   return bb->get_tree();
1461 }
1462
1463 tree
1464 var_to_tree(Bvariable* bv)
1465 {
1466   return bv->get_tree();
1467 }