1 // go-gcc.cc -- Go frontend to gcc IR.
2 // Copyright (C) 2011, 2012 Free Software Foundation, Inc.
3 // Contributed by Ian Lance Taylor, Google.
5 // This file is part of GCC.
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
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
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/>.
21 #include "go-system.h"
23 // This has to be included outside of extern "C", so we have to
24 // include it here before tree.h includes it later.
27 #ifndef ENABLE_BUILD_WITH_CXX
33 #include "tree-iterator.h"
37 #ifndef ENABLE_BUILD_WITH_CXX
46 // A class wrapping a tree.
63 // In gcc, types, expressions, and statements are all trees.
64 class Btype : public Gcc_tree
72 class Bexpression : public Gcc_tree
80 class Bstatement : public Gcc_tree
88 class Bfunction : public Gcc_tree
96 class Bblock : public Gcc_tree
104 class Bvariable : public Gcc_tree
112 class Blabel : public Gcc_tree
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.
126 class Gcc_backend : public Backend
133 { return this->make_type(error_mark_node); }
137 { return this->make_type(void_type_node); }
141 { return this->make_type(boolean_type_node); }
144 integer_type(bool, int);
153 pointer_type(Btype*);
156 function_type(const Btyped_identifier&,
157 const std::vector<Btyped_identifier>&,
158 const std::vector<Btyped_identifier>&,
162 struct_type(const std::vector<Btyped_identifier>&);
165 array_type(Btype*, Bexpression*);
168 placeholder_pointer_type(const std::string&, Location, bool);
171 set_placeholder_pointer_type(Btype*, Btype*);
174 set_placeholder_function_type(Btype*, Btype*);
177 placeholder_struct_type(const std::string&, Location);
180 set_placeholder_struct_type(Btype* placeholder,
181 const std::vector<Btyped_identifier>&);
184 placeholder_array_type(const std::string&, Location);
187 set_placeholder_array_type(Btype*, Btype*, Bexpression*);
190 named_type(const std::string&, Btype*, Location);
193 circular_pointer_type(Btype*, bool);
196 is_circular_pointer_type(Btype*);
202 type_alignment(Btype*);
205 type_field_alignment(Btype*);
208 type_field_offset(Btype*, size_t index);
213 zero_expression(Btype*);
219 { return this->make_statement(error_mark_node); }
222 expression_statement(Bexpression*);
225 init_statement(Bvariable* var, Bexpression* init);
228 assignment_statement(Bexpression* lhs, Bexpression* rhs, Location);
231 return_statement(Bfunction*, const std::vector<Bexpression*>&,
235 if_statement(Bexpression* condition, Bblock* then_block, Bblock* else_block,
239 switch_statement(Bexpression* value,
240 const std::vector<std::vector<Bexpression*> >& cases,
241 const std::vector<Bstatement*>& statements,
245 compound_statement(Bstatement*, Bstatement*);
248 statement_list(const std::vector<Bstatement*>&);
253 block(Bfunction*, Bblock*, const std::vector<Bvariable*>&,
257 block_add_statements(Bblock*, const std::vector<Bstatement*>&);
260 block_statement(Bblock*);
266 { return new Bvariable(error_mark_node); }
269 global_variable(const std::string& package_name,
270 const std::string& unique_prefix,
271 const std::string& name,
278 global_variable_set_init(Bvariable*, Bexpression*);
281 local_variable(Bfunction*, const std::string&, Btype*, bool,
285 parameter_variable(Bfunction*, const std::string&, Btype*, bool,
289 temporary_variable(Bfunction*, Bblock*, Btype*, Bexpression*, bool,
290 Location, Bstatement**);
293 immutable_struct(const std::string&, bool, Btype*, Location);
296 immutable_struct_set_init(Bvariable*, const std::string&, bool, Btype*,
297 Location, Bexpression*);
300 immutable_struct_reference(const std::string&, Btype*, Location);
305 label(Bfunction*, const std::string& name, Location);
308 label_definition_statement(Blabel*);
311 goto_statement(Blabel*, Location);
314 label_address(Blabel*, Location);
317 // Make a Bexpression from a tree.
319 make_expression(tree t)
320 { return new Bexpression(t); }
322 // Make a Bstatement from a tree.
324 make_statement(tree t)
325 { return new Bstatement(t); }
327 // Make a Btype from a tree.
330 { return new Btype(t); }
333 fill_in_struct(Btype*, const std::vector<Btyped_identifier>&);
336 fill_in_array(Btype*, Btype*, Bexpression*);
339 // A helper function.
342 get_identifier_from_string(const std::string& str)
344 return get_identifier_with_length(str.data(), str.length());
347 // Get an unnamed integer type.
350 Gcc_backend::integer_type(bool is_unsigned, int bits)
355 if (bits == INT_TYPE_SIZE)
356 type = unsigned_type_node;
357 else if (bits == CHAR_TYPE_SIZE)
358 type = unsigned_char_type_node;
359 else if (bits == SHORT_TYPE_SIZE)
360 type = short_unsigned_type_node;
361 else if (bits == LONG_TYPE_SIZE)
362 type = long_unsigned_type_node;
363 else if (bits == LONG_LONG_TYPE_SIZE)
364 type = long_long_unsigned_type_node;
366 type = make_unsigned_type(bits);
370 if (bits == INT_TYPE_SIZE)
371 type = integer_type_node;
372 else if (bits == CHAR_TYPE_SIZE)
373 type = signed_char_type_node;
374 else if (bits == SHORT_TYPE_SIZE)
375 type = short_integer_type_node;
376 else if (bits == LONG_TYPE_SIZE)
377 type = long_integer_type_node;
378 else if (bits == LONG_LONG_TYPE_SIZE)
379 type = long_long_integer_type_node;
381 type = make_signed_type(bits);
383 return this->make_type(type);
386 // Get an unnamed float type.
389 Gcc_backend::float_type(int bits)
392 if (bits == FLOAT_TYPE_SIZE)
393 type = float_type_node;
394 else if (bits == DOUBLE_TYPE_SIZE)
395 type = double_type_node;
396 else if (bits == LONG_DOUBLE_TYPE_SIZE)
397 type = long_double_type_node;
400 type = make_node(REAL_TYPE);
401 TYPE_PRECISION(type) = bits;
404 return this->make_type(type);
407 // Get an unnamed complex type.
410 Gcc_backend::complex_type(int bits)
413 if (bits == FLOAT_TYPE_SIZE * 2)
414 type = complex_float_type_node;
415 else if (bits == DOUBLE_TYPE_SIZE * 2)
416 type = complex_double_type_node;
417 else if (bits == LONG_DOUBLE_TYPE_SIZE * 2)
418 type = complex_long_double_type_node;
421 type = make_node(REAL_TYPE);
422 TYPE_PRECISION(type) = bits / 2;
424 type = build_complex_type(type);
426 return this->make_type(type);
429 // Get a pointer type.
432 Gcc_backend::pointer_type(Btype* to_type)
434 tree to_type_tree = to_type->get_tree();
435 if (to_type_tree == error_mark_node)
436 return this->error_type();
437 tree type = build_pointer_type(to_type_tree);
438 return this->make_type(type);
441 // Make a function type.
444 Gcc_backend::function_type(const Btyped_identifier& receiver,
445 const std::vector<Btyped_identifier>& parameters,
446 const std::vector<Btyped_identifier>& results,
449 tree args = NULL_TREE;
451 if (receiver.btype != NULL)
453 tree t = receiver.btype->get_tree();
454 if (t == error_mark_node)
455 return this->error_type();
456 *pp = tree_cons(NULL_TREE, t, NULL_TREE);
457 pp = &TREE_CHAIN(*pp);
460 for (std::vector<Btyped_identifier>::const_iterator p = parameters.begin();
461 p != parameters.end();
464 tree t = p->btype->get_tree();
465 if (t == error_mark_node)
466 return this->error_type();
467 *pp = tree_cons(NULL_TREE, t, NULL_TREE);
468 pp = &TREE_CHAIN(*pp);
471 // Varargs is handled entirely at the Go level. When converted to
472 // GENERIC functions are not varargs.
473 *pp = void_list_node;
477 result = void_type_node;
478 else if (results.size() == 1)
479 result = results.front().btype->get_tree();
482 result = make_node(RECORD_TYPE);
483 tree field_trees = NULL_TREE;
485 for (std::vector<Btyped_identifier>::const_iterator p = results.begin();
489 const std::string name = (p->name.empty()
492 tree name_tree = get_identifier_from_string(name);
493 tree field_type_tree = p->btype->get_tree();
494 if (field_type_tree == error_mark_node)
495 return this->error_type();
496 gcc_assert(TYPE_SIZE(field_type_tree) != NULL_TREE);
497 tree field = build_decl(location.gcc_location(), FIELD_DECL,
498 name_tree, field_type_tree);
499 DECL_CONTEXT(field) = result;
501 pp = &DECL_CHAIN(field);
503 TYPE_FIELDS(result) = field_trees;
506 if (result == error_mark_node)
507 return this->error_type();
509 tree fntype = build_function_type(result, args);
510 if (fntype == error_mark_node)
511 return this->error_type();
513 return this->make_type(build_pointer_type(fntype));
516 // Make a struct type.
519 Gcc_backend::struct_type(const std::vector<Btyped_identifier>& fields)
521 return this->fill_in_struct(this->make_type(make_node(RECORD_TYPE)), fields);
524 // Fill in the fields of a struct type.
527 Gcc_backend::fill_in_struct(Btype* fill,
528 const std::vector<Btyped_identifier>& fields)
530 tree fill_tree = fill->get_tree();
531 tree field_trees = NULL_TREE;
532 tree* pp = &field_trees;
533 for (std::vector<Btyped_identifier>::const_iterator p = fields.begin();
537 tree name_tree = get_identifier_from_string(p->name);
538 tree type_tree = p->btype->get_tree();
539 if (type_tree == error_mark_node)
540 return this->error_type();
541 tree field = build_decl(p->location.gcc_location(), FIELD_DECL, name_tree,
543 DECL_CONTEXT(field) = fill_tree;
545 pp = &DECL_CHAIN(field);
547 TYPE_FIELDS(fill_tree) = field_trees;
548 layout_type(fill_tree);
552 // Make an array type.
555 Gcc_backend::array_type(Btype* element_btype, Bexpression* length)
557 return this->fill_in_array(this->make_type(make_node(ARRAY_TYPE)),
558 element_btype, length);
561 // Fill in an array type.
564 Gcc_backend::fill_in_array(Btype* fill, Btype* element_type,
567 tree element_type_tree = element_type->get_tree();
568 tree length_tree = length->get_tree();
569 if (element_type_tree == error_mark_node || length_tree == error_mark_node)
570 return this->error_type();
572 gcc_assert(TYPE_SIZE(element_type_tree) != NULL_TREE);
574 length_tree = fold_convert(sizetype, length_tree);
576 // build_index_type takes the maximum index, which is one less than
578 tree index_type_tree = build_index_type(fold_build2(MINUS_EXPR, sizetype,
582 tree fill_tree = fill->get_tree();
583 TREE_TYPE(fill_tree) = element_type_tree;
584 TYPE_DOMAIN(fill_tree) = index_type_tree;
585 TYPE_ADDR_SPACE(fill_tree) = TYPE_ADDR_SPACE(element_type_tree);
586 layout_type(fill_tree);
588 if (TYPE_STRUCTURAL_EQUALITY_P(element_type_tree))
589 SET_TYPE_STRUCTURAL_EQUALITY(fill_tree);
590 else if (TYPE_CANONICAL(element_type_tree) != element_type_tree
591 || TYPE_CANONICAL(index_type_tree) != index_type_tree)
592 TYPE_CANONICAL(fill_tree) =
593 build_array_type(TYPE_CANONICAL(element_type_tree),
594 TYPE_CANONICAL(index_type_tree));
599 // Create a placeholder for a pointer type.
602 Gcc_backend::placeholder_pointer_type(const std::string& name,
603 Location location, bool)
605 tree ret = build_variant_type_copy(ptr_type_node);
608 tree decl = build_decl(location.gcc_location(), TYPE_DECL,
609 get_identifier_from_string(name),
611 TYPE_NAME(ret) = decl;
613 return this->make_type(ret);
616 // Set the real target type for a placeholder pointer type.
619 Gcc_backend::set_placeholder_pointer_type(Btype* placeholder,
622 tree pt = placeholder->get_tree();
623 if (pt == error_mark_node)
625 gcc_assert(TREE_CODE(pt) == POINTER_TYPE);
626 tree tt = to_type->get_tree();
627 if (tt == error_mark_node)
632 gcc_assert(TREE_CODE(tt) == POINTER_TYPE);
633 TREE_TYPE(pt) = TREE_TYPE(tt);
634 if (TYPE_NAME(pt) != NULL_TREE)
636 // Build the data structure gcc wants to see for a typedef.
637 tree copy = build_variant_type_copy(pt);
638 TYPE_NAME(copy) = NULL_TREE;
639 DECL_ORIGINAL_TYPE(TYPE_NAME(pt)) = copy;
644 // Set the real values for a placeholder function type.
647 Gcc_backend::set_placeholder_function_type(Btype* placeholder, Btype* ft)
649 return this->set_placeholder_pointer_type(placeholder, ft);
652 // Create a placeholder for a struct type.
655 Gcc_backend::placeholder_struct_type(const std::string& name,
658 tree ret = make_node(RECORD_TYPE);
659 tree decl = build_decl(location.gcc_location(), TYPE_DECL,
660 get_identifier_from_string(name),
662 TYPE_NAME(ret) = decl;
663 return this->make_type(ret);
666 // Fill in the fields of a placeholder struct type.
669 Gcc_backend::set_placeholder_struct_type(
671 const std::vector<Btyped_identifier>& fields)
673 tree t = placeholder->get_tree();
674 gcc_assert(TREE_CODE(t) == RECORD_TYPE && TYPE_FIELDS(t) == NULL_TREE);
675 Btype* r = this->fill_in_struct(placeholder, fields);
677 // Build the data structure gcc wants to see for a typedef.
678 tree copy = build_distinct_type_copy(t);
679 TYPE_NAME(copy) = NULL_TREE;
680 DECL_ORIGINAL_TYPE(TYPE_NAME(t)) = copy;
682 return r->get_tree() != error_mark_node;
685 // Create a placeholder for an array type.
688 Gcc_backend::placeholder_array_type(const std::string& name,
691 tree ret = make_node(ARRAY_TYPE);
692 tree decl = build_decl(location.gcc_location(), TYPE_DECL,
693 get_identifier_from_string(name),
695 TYPE_NAME(ret) = decl;
696 return this->make_type(ret);
699 // Fill in the fields of a placeholder array type.
702 Gcc_backend::set_placeholder_array_type(Btype* placeholder,
703 Btype* element_btype,
706 tree t = placeholder->get_tree();
707 gcc_assert(TREE_CODE(t) == ARRAY_TYPE && TREE_TYPE(t) == NULL_TREE);
708 Btype* r = this->fill_in_array(placeholder, element_btype, length);
710 // Build the data structure gcc wants to see for a typedef.
711 tree copy = build_distinct_type_copy(t);
712 TYPE_NAME(copy) = NULL_TREE;
713 DECL_ORIGINAL_TYPE(TYPE_NAME(t)) = copy;
715 return r->get_tree() != error_mark_node;
718 // Return a named version of a type.
721 Gcc_backend::named_type(const std::string& name, Btype* btype,
724 tree type = btype->get_tree();
725 if (type == error_mark_node)
726 return this->error_type();
728 // The middle-end expects a basic type to have a name. In Go every
729 // basic type will have a name. The first time we see a basic type,
730 // give it whatever Go name we have at this point.
731 if (TYPE_NAME(type) == NULL_TREE
732 && location.gcc_location() == BUILTINS_LOCATION
733 && (TREE_CODE(type) == INTEGER_TYPE
734 || TREE_CODE(type) == REAL_TYPE
735 || TREE_CODE(type) == COMPLEX_TYPE
736 || TREE_CODE(type) == BOOLEAN_TYPE))
738 tree decl = build_decl(BUILTINS_LOCATION, TYPE_DECL,
739 get_identifier_from_string(name),
741 TYPE_NAME(type) = decl;
742 return this->make_type(type);
745 tree copy = build_variant_type_copy(type);
746 tree decl = build_decl(location.gcc_location(), TYPE_DECL,
747 get_identifier_from_string(name),
749 DECL_ORIGINAL_TYPE(decl) = type;
750 TYPE_NAME(copy) = decl;
751 return this->make_type(copy);
754 // Return a pointer type used as a marker for a circular type.
757 Gcc_backend::circular_pointer_type(Btype*, bool)
759 return this->make_type(ptr_type_node);
762 // Return whether we might be looking at a circular type.
765 Gcc_backend::is_circular_pointer_type(Btype* btype)
767 return btype->get_tree() == ptr_type_node;
770 // Return the size of a type.
773 Gcc_backend::type_size(Btype* btype)
775 tree t = TYPE_SIZE_UNIT(btype->get_tree());
776 gcc_assert(TREE_CODE(t) == INTEGER_CST);
777 gcc_assert(TREE_INT_CST_HIGH(t) == 0);
778 unsigned HOST_WIDE_INT val_wide = TREE_INT_CST_LOW(t);
779 size_t ret = static_cast<size_t>(val_wide);
780 gcc_assert(ret == val_wide);
784 // Return the alignment of a type.
787 Gcc_backend::type_alignment(Btype* btype)
789 return TYPE_ALIGN_UNIT(btype->get_tree());
792 // Return the alignment of a struct field of type BTYPE.
795 Gcc_backend::type_field_alignment(Btype* btype)
797 return go_field_alignment(btype->get_tree());
800 // Return the offset of a field in a struct.
803 Gcc_backend::type_field_offset(Btype* btype, size_t index)
805 tree struct_tree = btype->get_tree();
806 gcc_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
807 tree field = TYPE_FIELDS(struct_tree);
808 for (; index > 0; --index)
810 field = DECL_CHAIN(field);
811 gcc_assert(field != NULL_TREE);
813 HOST_WIDE_INT offset_wide = int_byte_position(field);
814 gcc_assert(offset_wide >= 0);
815 size_t ret = static_cast<size_t>(offset_wide);
816 gcc_assert(ret == static_cast<unsigned HOST_WIDE_INT>(offset_wide));
820 // Return the zero value for a type.
823 Gcc_backend::zero_expression(Btype* btype)
825 tree t = btype->get_tree();
827 if (t == error_mark_node)
828 ret = error_mark_node;
830 ret = build_zero_cst(t);
831 return tree_to_expr(ret);
834 // An expression as a statement.
837 Gcc_backend::expression_statement(Bexpression* expr)
839 return this->make_statement(expr->get_tree());
842 // Variable initialization.
845 Gcc_backend::init_statement(Bvariable* var, Bexpression* init)
847 tree var_tree = var->get_tree();
848 tree init_tree = init->get_tree();
849 if (var_tree == error_mark_node || init_tree == error_mark_node)
850 return this->error_statement();
851 gcc_assert(TREE_CODE(var_tree) == VAR_DECL);
852 DECL_INITIAL(var_tree) = init_tree;
853 return this->make_statement(build1_loc(DECL_SOURCE_LOCATION(var_tree),
854 DECL_EXPR, void_type_node, var_tree));
860 Gcc_backend::assignment_statement(Bexpression* lhs, Bexpression* rhs,
863 tree lhs_tree = lhs->get_tree();
864 tree rhs_tree = rhs->get_tree();
865 if (lhs_tree == error_mark_node || rhs_tree == error_mark_node)
866 return this->error_statement();
867 return this->make_statement(fold_build2_loc(location.gcc_location(),
870 lhs_tree, rhs_tree));
876 Gcc_backend::return_statement(Bfunction* bfunction,
877 const std::vector<Bexpression*>& vals,
880 tree fntree = bfunction->get_tree();
881 if (fntree == error_mark_node)
882 return this->error_statement();
883 tree result = DECL_RESULT(fntree);
884 if (result == error_mark_node)
885 return this->error_statement();
888 ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR, void_type_node,
890 else if (vals.size() == 1)
892 tree val = vals.front()->get_tree();
893 if (val == error_mark_node)
894 return this->error_statement();
895 tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
896 void_type_node, result,
897 vals.front()->get_tree());
898 ret = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
899 void_type_node, set);
903 // To return multiple values, copy the values into a temporary
904 // variable of the right structure type, and then assign the
905 // temporary variable to the DECL_RESULT in the return
907 tree stmt_list = NULL_TREE;
908 tree rettype = TREE_TYPE(result);
909 tree rettmp = create_tmp_var(rettype, "RESULT");
910 tree field = TYPE_FIELDS(rettype);
911 for (std::vector<Bexpression*>::const_iterator p = vals.begin();
913 p++, field = DECL_CHAIN(field))
915 gcc_assert(field != NULL_TREE);
916 tree ref = fold_build3_loc(location.gcc_location(), COMPONENT_REF,
917 TREE_TYPE(field), rettmp, field,
919 tree val = (*p)->get_tree();
920 if (val == error_mark_node)
921 return this->error_statement();
922 tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
924 ref, (*p)->get_tree());
925 append_to_statement_list(set, &stmt_list);
927 gcc_assert(field == NULL_TREE);
928 tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
931 tree ret_expr = fold_build1_loc(location.gcc_location(), RETURN_EXPR,
932 void_type_node, set);
933 append_to_statement_list(ret_expr, &stmt_list);
936 return this->make_statement(ret);
942 Gcc_backend::if_statement(Bexpression* condition, Bblock* then_block,
943 Bblock* else_block, Location location)
945 tree cond_tree = condition->get_tree();
946 tree then_tree = then_block->get_tree();
947 tree else_tree = else_block == NULL ? NULL_TREE : else_block->get_tree();
948 if (cond_tree == error_mark_node
949 || then_tree == error_mark_node
950 || else_tree == error_mark_node)
951 return this->error_statement();
952 tree ret = build3_loc(location.gcc_location(), COND_EXPR, void_type_node,
953 cond_tree, then_tree, else_tree);
954 return this->make_statement(ret);
960 Gcc_backend::switch_statement(
962 const std::vector<std::vector<Bexpression*> >& cases,
963 const std::vector<Bstatement*>& statements,
964 Location switch_location)
966 gcc_assert(cases.size() == statements.size());
968 tree stmt_list = NULL_TREE;
969 std::vector<std::vector<Bexpression*> >::const_iterator pc = cases.begin();
970 for (std::vector<Bstatement*>::const_iterator ps = statements.begin();
971 ps != statements.end();
976 source_location loc = (*ps != NULL
977 ? EXPR_LOCATION((*ps)->get_tree())
979 tree label = create_artificial_label(loc);
980 tree c = build_case_label(NULL_TREE, NULL_TREE, label);
981 append_to_statement_list(c, &stmt_list);
985 for (std::vector<Bexpression*>::const_iterator pcv = pc->begin();
989 tree t = (*pcv)->get_tree();
990 if (t == error_mark_node)
991 return this->error_statement();
992 source_location loc = EXPR_LOCATION(t);
993 tree label = create_artificial_label(loc);
994 tree c = build_case_label((*pcv)->get_tree(), NULL_TREE, label);
995 append_to_statement_list(c, &stmt_list);
1001 tree t = (*ps)->get_tree();
1002 if (t == error_mark_node)
1003 return this->error_statement();
1004 append_to_statement_list(t, &stmt_list);
1008 tree tv = value->get_tree();
1009 if (tv == error_mark_node)
1010 return this->error_statement();
1011 tree t = build3_loc(switch_location.gcc_location(), SWITCH_EXPR,
1012 void_type_node, tv, stmt_list, NULL_TREE);
1013 return this->make_statement(t);
1016 // Pair of statements.
1019 Gcc_backend::compound_statement(Bstatement* s1, Bstatement* s2)
1021 tree stmt_list = NULL_TREE;
1022 tree t = s1->get_tree();
1023 if (t == error_mark_node)
1024 return this->error_statement();
1025 append_to_statement_list(t, &stmt_list);
1027 if (t == error_mark_node)
1028 return this->error_statement();
1029 append_to_statement_list(t, &stmt_list);
1030 return this->make_statement(stmt_list);
1033 // List of statements.
1036 Gcc_backend::statement_list(const std::vector<Bstatement*>& statements)
1038 tree stmt_list = NULL_TREE;
1039 for (std::vector<Bstatement*>::const_iterator p = statements.begin();
1040 p != statements.end();
1043 tree t = (*p)->get_tree();
1044 if (t == error_mark_node)
1045 return this->error_statement();
1046 append_to_statement_list(t, &stmt_list);
1048 return this->make_statement(stmt_list);
1051 // Make a block. For some reason gcc uses a dual structure for
1052 // blocks: BLOCK tree nodes and BIND_EXPR tree nodes. Since the
1053 // BIND_EXPR node points to the BLOCK node, we store the BIND_EXPR in
1057 Gcc_backend::block(Bfunction* function, Bblock* enclosing,
1058 const std::vector<Bvariable*>& vars,
1059 Location start_location,
1062 tree block_tree = make_node(BLOCK);
1063 if (enclosing == NULL)
1065 // FIXME: Permitting FUNCTION to be NULL is a temporary measure
1066 // until we have a proper representation of the init function.
1068 if (function == NULL)
1069 fndecl = current_function_decl;
1071 fndecl = function->get_tree();
1072 gcc_assert(fndecl != NULL_TREE);
1074 // We may have already created a block for local variables when
1075 // we take the address of a parameter.
1076 if (DECL_INITIAL(fndecl) == NULL_TREE)
1078 BLOCK_SUPERCONTEXT(block_tree) = fndecl;
1079 DECL_INITIAL(fndecl) = block_tree;
1083 tree superblock_tree = DECL_INITIAL(fndecl);
1084 BLOCK_SUPERCONTEXT(block_tree) = superblock_tree;
1086 for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
1088 pp = &BLOCK_CHAIN(*pp))
1095 tree superbind_tree = enclosing->get_tree();
1096 tree superblock_tree = BIND_EXPR_BLOCK(superbind_tree);
1097 gcc_assert(TREE_CODE(superblock_tree) == BLOCK);
1099 BLOCK_SUPERCONTEXT(block_tree) = superblock_tree;
1101 for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
1103 pp = &BLOCK_CHAIN(*pp))
1108 tree* pp = &BLOCK_VARS(block_tree);
1109 for (std::vector<Bvariable*>::const_iterator pv = vars.begin();
1113 *pp = (*pv)->get_tree();
1114 if (*pp != error_mark_node)
1115 pp = &DECL_CHAIN(*pp);
1119 TREE_USED(block_tree) = 1;
1121 tree bind_tree = build3_loc(start_location.gcc_location(), BIND_EXPR,
1122 void_type_node, BLOCK_VARS(block_tree),
1123 NULL_TREE, block_tree);
1124 TREE_SIDE_EFFECTS(bind_tree) = 1;
1126 return new Bblock(bind_tree);
1129 // Add statements to a block.
1132 Gcc_backend::block_add_statements(Bblock* bblock,
1133 const std::vector<Bstatement*>& statements)
1135 tree stmt_list = NULL_TREE;
1136 for (std::vector<Bstatement*>::const_iterator p = statements.begin();
1137 p != statements.end();
1140 tree s = (*p)->get_tree();
1141 if (s != error_mark_node)
1142 append_to_statement_list(s, &stmt_list);
1145 tree bind_tree = bblock->get_tree();
1146 gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
1147 BIND_EXPR_BODY(bind_tree) = stmt_list;
1150 // Return a block as a statement.
1153 Gcc_backend::block_statement(Bblock* bblock)
1155 tree bind_tree = bblock->get_tree();
1156 gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
1157 return this->make_statement(bind_tree);
1160 // Make a global variable.
1163 Gcc_backend::global_variable(const std::string& package_name,
1164 const std::string& unique_prefix,
1165 const std::string& name,
1171 tree type_tree = btype->get_tree();
1172 if (type_tree == error_mark_node)
1173 return this->error_variable();
1175 std::string var_name(package_name);
1176 var_name.push_back('.');
1177 var_name.append(name);
1178 tree decl = build_decl(location.gcc_location(), VAR_DECL,
1179 get_identifier_from_string(var_name),
1182 DECL_EXTERNAL(decl) = 1;
1184 TREE_STATIC(decl) = 1;
1187 TREE_PUBLIC(decl) = 1;
1189 std::string asm_name(unique_prefix);
1190 asm_name.push_back('.');
1191 asm_name.append(var_name);
1192 SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(asm_name));
1194 TREE_USED(decl) = 1;
1196 go_preserve_from_gc(decl);
1198 return new Bvariable(decl);
1201 // Set the initial value of a global variable.
1204 Gcc_backend::global_variable_set_init(Bvariable* var, Bexpression* expr)
1206 tree expr_tree = expr->get_tree();
1207 if (expr_tree == error_mark_node)
1209 gcc_assert(TREE_CONSTANT(expr_tree));
1210 tree var_decl = var->get_tree();
1211 if (var_decl == error_mark_node)
1213 DECL_INITIAL(var_decl) = expr_tree;
1216 // Make a local variable.
1219 Gcc_backend::local_variable(Bfunction* function, const std::string& name,
1220 Btype* btype, bool is_address_taken,
1223 tree type_tree = btype->get_tree();
1224 if (type_tree == error_mark_node)
1225 return this->error_variable();
1226 tree decl = build_decl(location.gcc_location(), VAR_DECL,
1227 get_identifier_from_string(name),
1229 DECL_CONTEXT(decl) = function->get_tree();
1230 TREE_USED(decl) = 1;
1231 if (is_address_taken)
1232 TREE_ADDRESSABLE(decl) = 1;
1233 go_preserve_from_gc(decl);
1234 return new Bvariable(decl);
1237 // Make a function parameter variable.
1240 Gcc_backend::parameter_variable(Bfunction* function, const std::string& name,
1241 Btype* btype, bool is_address_taken,
1244 tree type_tree = btype->get_tree();
1245 if (type_tree == error_mark_node)
1246 return this->error_variable();
1247 tree decl = build_decl(location.gcc_location(), PARM_DECL,
1248 get_identifier_from_string(name),
1250 DECL_CONTEXT(decl) = function->get_tree();
1251 DECL_ARG_TYPE(decl) = type_tree;
1252 TREE_USED(decl) = 1;
1253 if (is_address_taken)
1254 TREE_ADDRESSABLE(decl) = 1;
1255 go_preserve_from_gc(decl);
1256 return new Bvariable(decl);
1259 // Make a temporary variable.
1262 Gcc_backend::temporary_variable(Bfunction* function, Bblock* bblock,
1263 Btype* btype, Bexpression* binit,
1264 bool is_address_taken,
1266 Bstatement** pstatement)
1268 tree type_tree = btype->get_tree();
1269 tree init_tree = binit == NULL ? NULL_TREE : binit->get_tree();
1270 if (type_tree == error_mark_node || init_tree == error_mark_node)
1272 *pstatement = this->error_statement();
1273 return this->error_variable();
1277 // We can only use create_tmp_var if the type is not addressable.
1278 if (!TREE_ADDRESSABLE(type_tree))
1279 var = create_tmp_var(type_tree, "GOTMP");
1282 gcc_assert(bblock != NULL);
1283 var = build_decl(location.gcc_location(), VAR_DECL,
1284 create_tmp_var_name("GOTMP"),
1286 DECL_ARTIFICIAL(var) = 1;
1287 DECL_IGNORED_P(var) = 1;
1289 // FIXME: Permitting function to be NULL here is a temporary
1290 // measure until we have a proper representation of the init
1292 if (function != NULL)
1293 DECL_CONTEXT(var) = function->get_tree();
1296 gcc_assert(current_function_decl != NULL_TREE);
1297 DECL_CONTEXT(var) = current_function_decl;
1300 // We have to add this variable to the BLOCK and the BIND_EXPR.
1301 tree bind_tree = bblock->get_tree();
1302 gcc_assert(TREE_CODE(bind_tree) == BIND_EXPR);
1303 tree block_tree = BIND_EXPR_BLOCK(bind_tree);
1304 gcc_assert(TREE_CODE(block_tree) == BLOCK);
1305 DECL_CHAIN(var) = BLOCK_VARS(block_tree);
1306 BLOCK_VARS(block_tree) = var;
1307 BIND_EXPR_VARS(bind_tree) = BLOCK_VARS(block_tree);
1310 if (init_tree != NULL_TREE)
1311 DECL_INITIAL(var) = fold_convert_loc(location.gcc_location(), type_tree,
1314 if (is_address_taken)
1315 TREE_ADDRESSABLE(var) = 1;
1317 *pstatement = this->make_statement(build1_loc(location.gcc_location(),
1319 void_type_node, var));
1320 return new Bvariable(var);
1323 // Create a named immutable initialized data structure.
1326 Gcc_backend::immutable_struct(const std::string& name, bool, Btype* btype,
1329 tree type_tree = btype->get_tree();
1330 if (type_tree == error_mark_node)
1331 return this->error_variable();
1332 gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
1333 tree decl = build_decl(location.gcc_location(), VAR_DECL,
1334 get_identifier_from_string(name),
1335 build_qualified_type(type_tree, TYPE_QUAL_CONST));
1336 TREE_STATIC(decl) = 1;
1337 TREE_READONLY(decl) = 1;
1338 TREE_CONSTANT(decl) = 1;
1339 TREE_USED(decl) = 1;
1340 DECL_ARTIFICIAL(decl) = 1;
1342 // We don't call rest_of_decl_compilation until we have the
1345 go_preserve_from_gc(decl);
1346 return new Bvariable(decl);
1349 // Set the initializer for a variable created by immutable_struct.
1350 // This is where we finish compiling the variable.
1353 Gcc_backend::immutable_struct_set_init(Bvariable* var, const std::string&,
1354 bool is_common, Btype*,
1356 Bexpression* initializer)
1358 tree decl = var->get_tree();
1359 tree init_tree = initializer->get_tree();
1360 if (decl == error_mark_node || init_tree == error_mark_node)
1363 DECL_INITIAL(decl) = init_tree;
1365 // We can't call make_decl_one_only until we set DECL_INITIAL.
1367 TREE_PUBLIC(decl) = 1;
1370 make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
1371 resolve_unique_section(decl, 1, 0);
1374 rest_of_decl_compilation(decl, 1, 0);
1377 // Return a reference to an immutable initialized data structure
1378 // defined in another package.
1381 Gcc_backend::immutable_struct_reference(const std::string& name, Btype* btype,
1384 tree type_tree = btype->get_tree();
1385 if (type_tree == error_mark_node)
1386 return this->error_variable();
1387 gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
1388 tree decl = build_decl(location.gcc_location(), VAR_DECL,
1389 get_identifier_from_string(name),
1390 build_qualified_type(type_tree, TYPE_QUAL_CONST));
1391 TREE_READONLY(decl) = 1;
1392 TREE_CONSTANT(decl) = 1;
1393 DECL_ARTIFICIAL(decl) = 1;
1394 TREE_PUBLIC(decl) = 1;
1395 DECL_EXTERNAL(decl) = 1;
1396 go_preserve_from_gc(decl);
1397 return new Bvariable(decl);
1403 Gcc_backend::label(Bfunction* function, const std::string& name,
1408 decl = create_artificial_label(location.gcc_location());
1411 tree id = get_identifier_from_string(name);
1412 decl = build_decl(location.gcc_location(), LABEL_DECL, id,
1414 DECL_CONTEXT(decl) = function->get_tree();
1416 return new Blabel(decl);
1419 // Make a statement which defines a label.
1422 Gcc_backend::label_definition_statement(Blabel* label)
1424 tree lab = label->get_tree();
1425 tree ret = fold_build1_loc(DECL_SOURCE_LOCATION(lab), LABEL_EXPR,
1426 void_type_node, lab);
1427 return this->make_statement(ret);
1430 // Make a goto statement.
1433 Gcc_backend::goto_statement(Blabel* label, Location location)
1435 tree lab = label->get_tree();
1436 tree ret = fold_build1_loc(location.gcc_location(), GOTO_EXPR, void_type_node,
1438 return this->make_statement(ret);
1441 // Get the address of a label.
1444 Gcc_backend::label_address(Blabel* label, Location location)
1446 tree lab = label->get_tree();
1448 TREE_ADDRESSABLE(lab) = 1;
1449 tree ret = fold_convert_loc(location.gcc_location(), ptr_type_node,
1450 build_fold_addr_expr_loc(location.gcc_location(),
1452 return this->make_expression(ret);
1455 // The single backend.
1457 static Gcc_backend gcc_backend;
1459 // Return the backend generator.
1464 return &gcc_backend;
1467 // FIXME: Temporary functions while converting to the new backend
1471 tree_to_type(tree t)
1473 return new Btype(t);
1477 tree_to_expr(tree t)
1479 return new Bexpression(t);
1483 tree_to_stat(tree t)
1485 return new Bstatement(t);
1489 tree_to_function(tree t)
1491 return new Bfunction(t);
1495 tree_to_block(tree t)
1497 gcc_assert(TREE_CODE(t) == BIND_EXPR);
1498 return new Bblock(t);
1502 type_to_tree(Btype* bt)
1504 return bt->get_tree();
1508 expr_to_tree(Bexpression* be)
1510 return be->get_tree();
1514 stat_to_tree(Bstatement* bs)
1516 return bs->get_tree();
1520 block_to_tree(Bblock* bb)
1522 return bb->get_tree();
1526 var_to_tree(Bvariable* bv)
1528 return bv->get_tree();