OSDN Git Service

Use backend types for all type conversions.
authorian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Sat, 7 May 2011 00:12:32 +0000 (00:12 +0000)
committerian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Sat, 7 May 2011 00:12:32 +0000 (00:12 +0000)
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@173520 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/go/gofrontend/expressions.cc
gcc/go/gofrontend/gogo-tree.cc
gcc/go/gofrontend/gogo.cc
gcc/go/gofrontend/statements.cc
gcc/go/gofrontend/types.cc
gcc/go/gofrontend/types.h

index 2c330ef..9338486 100644 (file)
@@ -214,7 +214,7 @@ Expression::convert_for_assignment(Translate_context* context, Type* lhs_type,
 
   Gogo* gogo = context->gogo();
 
-  tree lhs_type_tree = lhs_type->get_tree(gogo);
+  tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
   if (lhs_type_tree == error_mark_node)
     return error_mark_node;
 
@@ -323,7 +323,7 @@ Expression::convert_type_to_interface(Translate_context* context,
   // This should have been checked already.
   go_assert(lhs_interface_type->implements_interface(rhs_type, NULL));
 
-  tree lhs_type_tree = lhs_type->get_tree(gogo);
+  tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
   if (lhs_type_tree == error_mark_node)
     return error_mark_node;
 
@@ -456,7 +456,7 @@ Expression::convert_interface_to_interface(Translate_context* context,
   Interface_type* lhs_interface_type = lhs_type->interface_type();
   bool lhs_is_empty = lhs_interface_type->is_empty();
 
-  tree lhs_type_tree = lhs_type->get_tree(gogo);
+  tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
   if (lhs_type_tree == error_mark_node)
     return error_mark_node;
 
@@ -567,7 +567,7 @@ Expression::convert_interface_to_type(Translate_context* context,
   Gogo* gogo = context->gogo();
   tree rhs_type_tree = TREE_TYPE(rhs_tree);
 
-  tree lhs_type_tree = lhs_type->get_tree(gogo);
+  tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
   if (lhs_type_tree == error_mark_node)
     return error_mark_node;
 
@@ -1041,7 +1041,8 @@ Temporary_reference_expression::do_get_tree(Translate_context* context)
   tree ret = var_to_tree(bvar);
   if (POINTER_TYPE_P(TREE_TYPE(ret)) && VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
     {
-      tree type_tree = this->type()->base()->get_tree(context->gogo());
+      Btype* type_btype = this->type()->base()->get_backend(context->gogo());
+      tree type_tree = type_to_tree(type_btype);
       ret = fold_convert_loc(this->location(), type_tree, ret);
     }
   return ret;
@@ -1119,8 +1120,8 @@ Sink_expression::do_get_tree(Translate_context* context)
   if (this->var_ == NULL_TREE)
     {
       go_assert(this->type_ != NULL && !this->type_->is_sink_type());
-      this->var_ = create_tmp_var(this->type_->get_tree(context->gogo()),
-                                 "blank");
+      Btype* bt = this->type_->get_backend(context->gogo());
+      this->var_ = create_tmp_var(type_to_tree(bt), "blank");
     }
   return this->var_;
 }
@@ -1701,16 +1702,18 @@ Integer_expression::do_get_tree(Translate_context* context)
   Gogo* gogo = context->gogo();
   tree type;
   if (this->type_ != NULL && !this->type_->is_abstract())
-    type = this->type_->get_tree(gogo);
+    type = type_to_tree(this->type_->get_backend(gogo));
   else if (this->type_ != NULL && this->type_->float_type() != NULL)
     {
       // We are converting to an abstract floating point type.
-      type = Type::lookup_float_type("float64")->get_tree(gogo);
+      Type* ftype = Type::lookup_float_type("float64");
+      type = type_to_tree(ftype->get_backend(gogo));
     }
   else if (this->type_ != NULL && this->type_->complex_type() != NULL)
     {
       // We are converting to an abstract complex type.
-      type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+      Type* ctype = Type::lookup_complex_type("complex128");
+      type = type_to_tree(ctype->get_backend(gogo));
     }
   else
     {
@@ -1720,9 +1723,15 @@ Integer_expression::do_get_tree(Translate_context* context)
       // not <=, because we need an extra bit for the sign bit.
       int bits = mpz_sizeinbase(this->val_, 2);
       if (bits < INT_TYPE_SIZE)
-       type = Type::lookup_integer_type("int")->get_tree(gogo);
+       {
+         Type* t = Type::lookup_integer_type("int");
+         type = type_to_tree(t->get_backend(gogo));
+       }
       else if (bits < 64)
-       type = Type::lookup_integer_type("int64")->get_tree(gogo);
+       {
+         Type* t = Type::lookup_integer_type("int64");
+         type = type_to_tree(t->get_backend(gogo));
+       }
       else
        type = long_long_integer_type_node;
     }
@@ -2028,18 +2037,19 @@ Float_expression::do_get_tree(Translate_context* context)
   Gogo* gogo = context->gogo();
   tree type;
   if (this->type_ != NULL && !this->type_->is_abstract())
-    type = this->type_->get_tree(gogo);
+    type = type_to_tree(this->type_->get_backend(gogo));
   else if (this->type_ != NULL && this->type_->integer_type() != NULL)
     {
       // We have an abstract integer type.  We just hope for the best.
-      type = Type::lookup_integer_type("int")->get_tree(gogo);
+      type = type_to_tree(Type::lookup_integer_type("int")->get_backend(gogo));
     }
   else
     {
       // If we still have an abstract type here, then this is being
       // used in a constant expression which didn't get reduced.  We
       // just use float64 and hope for the best.
-      type = Type::lookup_float_type("float64")->get_tree(gogo);
+      Type* ft = Type::lookup_float_type("float64");
+      type = type_to_tree(ft->get_backend(gogo));
     }
   return Expression::float_constant_tree(this->val_, type);
 }
@@ -2266,13 +2276,14 @@ Complex_expression::do_get_tree(Translate_context* context)
   Gogo* gogo = context->gogo();
   tree type;
   if (this->type_ != NULL && !this->type_->is_abstract())
-    type = this->type_->get_tree(gogo);
+    type = type_to_tree(this->type_->get_backend(gogo));
   else
     {
       // If we still have an abstract type here, this this is being
       // used in a constant expression which didn't get reduced.  We
       // just use complex128 and hope for the best.
-      type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+      Type* ct = Type::lookup_complex_type("complex128");
+      type = type_to_tree(ct->get_backend(gogo));
     }
   return Expression::complex_constant_tree(this->real_, this->imag_, type);
 }
@@ -2718,7 +2729,7 @@ Const_expression::do_get_tree(Translate_context* context)
     type_tree = NULL_TREE;
   else
     {
-      type_tree = this->type_->get_tree(gogo);
+      type_tree = type_to_tree(this->type_->get_backend(gogo));
       if (type_tree == error_mark_node)
        return error_mark_node;
     }
@@ -3344,7 +3355,7 @@ tree
 Type_conversion_expression::do_get_tree(Translate_context* context)
 {
   Gogo* gogo = context->gogo();
-  tree type_tree = this->type_->get_tree(gogo);
+  tree type_tree = type_to_tree(this->type_->get_backend(gogo));
   tree expr_tree = this->expr_->get_tree(context);
 
   if (type_tree == error_mark_node
@@ -3601,7 +3612,7 @@ Unsafe_type_conversion_expression::do_get_tree(Translate_context* context)
   Type* t = this->type_;
   Type* et = this->expr_->type();
 
-  tree type_tree = this->type_->get_tree(context->gogo());
+  tree type_tree = type_to_tree(this->type_->get_backend(context->gogo()));
   tree expr_tree = this->expr_->get_tree(context);
   if (type_tree == error_mark_node || expr_tree == error_mark_node)
     return error_mark_node;
@@ -4304,7 +4315,7 @@ Unary_expression::do_get_tree(Translate_context* context)
        if (TREE_TYPE(TREE_TYPE(expr)) == ptr_type_node)
          {
            Type* pt = this->expr_->type()->points_to();
-           tree ind = pt->get_tree(context->gogo());
+           tree ind = type_to_tree(pt->get_backend(context->gogo()));
            expr = fold_convert_loc(loc, build_pointer_type(ind), expr);
          }
 
@@ -5984,7 +5995,8 @@ Binary_expression::do_get_tree(Translate_context* context)
   if (this->left_->type()->is_string_type())
     {
       go_assert(this->op_ == OPERATOR_PLUS);
-      tree string_type = Type::make_string_type()->get_tree(context->gogo());
+      Type* st = Type::make_string_type();
+      tree string_type = type_to_tree(st->get_backend(context->gogo()));
       static tree string_plus_decl;
       return Gogo::call_builtin(&string_plus_decl,
                                this->location(),
@@ -6313,7 +6325,8 @@ Expression::comparison_tree(Translate_context* context, Operator op,
 
   if (left_type->is_string_type() && right_type->is_string_type())
     {
-      tree string_type = Type::make_string_type()->get_tree(context->gogo());
+      Type* st = Type::make_string_type();
+      tree string_type = type_to_tree(st->get_backend(context->gogo()));
       static tree string_compare_decl;
       left_tree = Gogo::call_builtin(&string_compare_decl,
                                     location,
@@ -7151,7 +7164,7 @@ Builtin_call_expression::do_integer_constant_value(bool iota_is_constant,
        return false;
       if (arg_type->named_type() != NULL)
        arg_type->named_type()->convert(this->gogo_);
-      tree arg_type_tree = arg_type->get_tree(this->gogo_);
+      tree arg_type_tree = type_to_tree(arg_type->get_backend(this->gogo_));
       if (arg_type_tree == error_mark_node)
        return false;
       unsigned long val_long;
@@ -7197,7 +7210,7 @@ Builtin_call_expression::do_integer_constant_value(bool iota_is_constant,
        return false;
       if (st->named_type() != NULL)
        st->named_type()->convert(this->gogo_);
-      tree struct_tree = st->get_tree(this->gogo_);
+      tree struct_tree = type_to_tree(st->get_backend(this->gogo_));
       go_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
       tree field = TYPE_FIELDS(struct_tree);
       for (unsigned int index = farg->field_index(); index > 0; --index)
@@ -7792,24 +7805,26 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
              }
            else if (arg_type->map_type() != NULL)
              {
+               tree arg_type_tree = type_to_tree(arg_type->get_backend(gogo));
                static tree map_len_fndecl;
                val_tree = Gogo::call_builtin(&map_len_fndecl,
                                              location,
                                              "__go_map_len",
                                              1,
                                              integer_type_node,
-                                             arg_type->get_tree(gogo),
+                                             arg_type_tree,
                                              arg_tree);
              }
            else if (arg_type->channel_type() != NULL)
              {
+               tree arg_type_tree = type_to_tree(arg_type->get_backend(gogo));
                static tree chan_len_fndecl;
                val_tree = Gogo::call_builtin(&chan_len_fndecl,
                                              location,
                                              "__go_chan_len",
                                              1,
                                              integer_type_node,
-                                             arg_type->get_tree(gogo),
+                                             arg_type_tree,
                                              arg_tree);
              }
            else
@@ -7831,13 +7846,14 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
              }
            else if (arg_type->channel_type() != NULL)
              {
+               tree arg_type_tree = type_to_tree(arg_type->get_backend(gogo));
                static tree chan_cap_fndecl;
                val_tree = Gogo::call_builtin(&chan_cap_fndecl,
                                              location,
                                              "__go_chan_cap",
                                              1,
                                              integer_type_node,
-                                             arg_type->get_tree(gogo),
+                                             arg_type_tree,
                                              arg_tree);
              }
            else
@@ -7847,7 +7863,8 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
        if (val_tree == error_mark_node)
          return error_mark_node;
 
-       tree type_tree = Type::lookup_integer_type("int")->get_tree(gogo);
+       Type* int_type = Type::lookup_integer_type("int");
+       tree type_tree = type_to_tree(int_type->get_backend(gogo));
        if (type_tree == TREE_TYPE(val_tree))
          return val_tree;
        else
@@ -7901,8 +7918,8 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
                    pfndecl = &print_uint64_fndecl;
                    fnname = "__go_print_uint64";
                    Type* itype = Type::lookup_integer_type("uint64");
-                   arg = fold_convert_loc(location, itype->get_tree(gogo),
-                                          arg);
+                   Btype* bitype = itype->get_backend(gogo);
+                   arg = fold_convert_loc(location, type_to_tree(bitype), arg);
                  }
                else if (type->integer_type() != NULL)
                  {
@@ -7910,8 +7927,8 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
                    pfndecl = &print_int64_fndecl;
                    fnname = "__go_print_int64";
                    Type* itype = Type::lookup_integer_type("int64");
-                   arg = fold_convert_loc(location, itype->get_tree(gogo),
-                                          arg);
+                   Btype* bitype = itype->get_backend(gogo);
+                   arg = fold_convert_loc(location, type_to_tree(bitype), arg);
                  }
                else if (type->float_type() != NULL)
                  {
@@ -8038,7 +8055,7 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
          return error_mark_node;
 
        Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
-       tree empty_tree = empty->get_tree(context->gogo());
+       tree empty_tree = type_to_tree(empty->get_backend(context->gogo()));
 
        Type* nil_type = Type::make_nil_type();
        Expression* nil = Expression::make_nil(location);
@@ -8108,7 +8125,8 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
            go_assert(saw_errors());
            return error_mark_node;
          }
-       tree type = Type::lookup_integer_type("int")->get_tree(gogo);
+       Type* int_type = Type::lookup_integer_type("int");
+       tree type = type_to_tree(int_type->get_backend(gogo));
        tree ret = Expression::integer_constant_tree(val, type);
        mpz_clear(val);
        return ret;
@@ -8163,7 +8181,8 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
        len = save_expr(len);
 
        Type* element_type = at->element_type();
-       tree element_type_tree = element_type->get_tree(gogo);
+       Btype* element_btype = element_type->get_backend(gogo);
+       tree element_type_tree = type_to_tree(element_btype);
        if (element_type_tree == error_mark_node)
          return error_mark_node;
        tree element_size = TYPE_SIZE_UNIT(element_type_tree);
@@ -8226,7 +8245,7 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
        arg2_val = fold_convert_loc(location, ptr_type_node, arg2_val);
        arg2_len = fold_convert_loc(location, size_type_node, arg2_len);
 
-       tree element_type_tree = element_type->get_tree(gogo);
+       tree element_type_tree = type_to_tree(element_type->get_backend(gogo));
        if (element_type_tree == error_mark_node)
          return error_mark_node;
        tree element_size = TYPE_SIZE_UNIT(element_type_tree);
@@ -8813,7 +8832,8 @@ Call_expression::bound_method_function(Translate_context* context,
     {
       if (fatype->points_to() == NULL)
        fatype = Type::make_pointer_type(fatype);
-      first_arg = fold_convert(fatype->get_tree(context->gogo()), first_arg);
+      Btype* bfatype = fatype->get_backend(context->gogo());
+      first_arg = fold_convert(type_to_tree(bfatype), first_arg);
       if (first_arg == error_mark_node
          || TREE_TYPE(first_arg) == error_mark_node)
        return error_mark_node;
@@ -8910,7 +8930,7 @@ Call_expression::do_get_tree(Translate_context* context)
       go_assert(i == nargs);
     }
 
-  tree rettype = TREE_TYPE(TREE_TYPE(fntype->get_tree(gogo)));
+  tree rettype = TREE_TYPE(TREE_TYPE(type_to_tree(fntype->get_backend(gogo))));
   if (rettype == error_mark_node)
     {
       delete[] args;
@@ -8943,7 +8963,7 @@ Call_expression::do_get_tree(Translate_context* context)
   // type which refers to itself.
   if (!DECL_P(fndecl) || !DECL_IS_BUILTIN(fndecl))
     {
-      tree fnt = fntype->get_tree(gogo);
+      tree fnt = type_to_tree(fntype->get_backend(gogo));
       if (fnt == error_mark_node)
        return error_mark_node;
       fn = fold_convert_loc(location, fnt, fn);
@@ -8995,7 +9015,7 @@ Call_expression::do_get_tree(Translate_context* context)
   // to the correct type.
   if (TREE_TYPE(ret) == ptr_type_node)
     {
-      tree t = this->type()->base()->get_tree(gogo);
+      tree t = type_to_tree(this->type()->base()->get_backend(gogo));
       ret = fold_convert_loc(location, t, ret);
     }
 
@@ -9469,7 +9489,7 @@ Array_index_expression::do_get_tree(Translate_context* context)
       return error_mark_node;
     }
 
-  tree type_tree = array_type->get_tree(gogo);
+  tree type_tree = type_to_tree(array_type->get_backend(gogo));
   if (type_tree == error_mark_node)
     return error_mark_node;
 
@@ -9536,7 +9556,9 @@ Array_index_expression::do_get_tree(Translate_context* context)
        {
          // Open array.
          tree values = array_type->value_pointer_tree(gogo, array_tree);
-         tree element_type_tree = array_type->element_type()->get_tree(gogo);
+         Type* element_type = array_type->element_type();
+         Btype* belement_type = element_type->get_backend(gogo);
+         tree element_type_tree = type_to_tree(belement_type);
          if (element_type_tree == error_mark_node)
            return error_mark_node;
          tree element_size = TYPE_SIZE_UNIT(element_type_tree);
@@ -9585,7 +9607,8 @@ Array_index_expression::do_get_tree(Translate_context* context)
                                  bad_index, bad_end);
     }
 
-  tree element_type_tree = array_type->element_type()->get_tree(gogo);
+  Type* element_type = array_type->element_type();
+  tree element_type_tree = type_to_tree(element_type->get_backend(gogo));
   if (element_type_tree == error_mark_node)
     return error_mark_node;
   tree element_size = TYPE_SIZE_UNIT(element_type_tree);
@@ -9608,7 +9631,7 @@ Array_index_expression::do_get_tree(Translate_context* context)
   tree result_capacity_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
                                              capacity_tree, start_tree);
 
-  tree struct_tree = this->type()->get_tree(gogo);
+  tree struct_tree = type_to_tree(this->type()->get_backend(gogo));
   go_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
 
   VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
@@ -10098,7 +10121,8 @@ Map_index_expression::get_value_pointer(Translate_context* context,
   // an uncomparable or unhashable type.
   TREE_NOTHROW(map_index_fndecl) = 0;
 
-  tree val_type_tree = type->val_type()->get_tree(context->gogo());
+  Type* val_type = type->val_type();
+  tree val_type_tree = type_to_tree(val_type->get_backend(context->gogo()));
   if (val_type_tree == error_mark_node)
     return error_mark_node;
   tree ptr_val_type_tree = build_pointer_type(val_type_tree);
@@ -10629,7 +10653,7 @@ Allocation_expression::do_check_types(Gogo*)
 tree
 Allocation_expression::do_get_tree(Translate_context* context)
 {
-  tree type_tree = this->type_->get_tree(context->gogo());
+  tree type_tree = type_to_tree(this->type_->get_backend(context->gogo()));
   if (type_tree == error_mark_node)
     return error_mark_node;
   tree size_tree = TYPE_SIZE_UNIT(type_tree);
@@ -10933,7 +10957,7 @@ Struct_construction_expression::do_get_tree(Translate_context* context)
   if (this->vals_ == NULL)
     return this->type_->get_init_tree(gogo, false);
 
-  tree type_tree = this->type_->get_tree(gogo);
+  tree type_tree = type_to_tree(this->type_->get_backend(gogo));
   if (type_tree == error_mark_node)
     return error_mark_node;
   go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
@@ -11269,8 +11293,9 @@ class Fixed_array_construction_expression :
 tree
 Fixed_array_construction_expression::do_get_tree(Translate_context* context)
 {
-  return this->get_constructor_tree(context,
-                                   this->type()->get_tree(context->gogo()));
+  Type* type = this->type();
+  Btype* btype = type->get_backend(context->gogo());
+  return this->get_constructor_tree(context, type_to_tree(btype));
 }
 
 // Construct an open array.
@@ -11317,7 +11342,8 @@ Open_array_construction_expression::do_get_tree(Translate_context* context)
     }
 
   Type* element_type = array_type->element_type();
-  tree element_type_tree = element_type->get_tree(context->gogo());
+  Btype* belement_type = element_type->get_backend(context->gogo());
+  tree element_type_tree = type_to_tree(belement_type);
   if (element_type_tree == error_mark_node)
     return error_mark_node;
 
@@ -11410,7 +11436,7 @@ Open_array_construction_expression::do_get_tree(Translate_context* context)
 
   // Build a constructor for the open array.
 
-  tree type_tree = this->type()->get_tree(context->gogo());
+  tree type_tree = type_to_tree(this->type()->get_backend(context->gogo()));
   if (type_tree == error_mark_node)
     return error_mark_node;
   go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
@@ -11587,7 +11613,7 @@ Map_construction_expression::do_get_tree(Translate_context* context)
 
   Type* key_type = mt->key_type();
   tree id = get_identifier("__key");
-  tree key_type_tree = key_type->get_tree(gogo);
+  tree key_type_tree = type_to_tree(key_type->get_backend(gogo));
   if (key_type_tree == error_mark_node)
     return error_mark_node;
   tree key_field = build_decl(loc, FIELD_DECL, id, key_type_tree);
@@ -11596,7 +11622,7 @@ Map_construction_expression::do_get_tree(Translate_context* context)
 
   Type* val_type = mt->val_type();
   id = get_identifier("__val");
-  tree val_type_tree = val_type->get_tree(gogo);
+  tree val_type_tree = type_to_tree(val_type->get_backend(gogo));
   if (val_type_tree == error_mark_node)
     return error_mark_node;
   tree val_field = build_decl(loc, FIELD_DECL, id, val_type_tree);
@@ -11699,7 +11725,7 @@ Map_construction_expression::do_get_tree(Translate_context* context)
 
   tree descriptor = gogo->map_descriptor(mt);
 
-  tree type_tree = this->type_->get_tree(gogo);
+  tree type_tree = type_to_tree(this->type_->get_backend(gogo));
   if (type_tree == error_mark_node)
     return error_mark_node;
 
@@ -12345,10 +12371,12 @@ Type_guard_expression::do_get_tree(Translate_context* context)
           || expr_type->integer_type() != NULL))
       || (expr_type->is_unsafe_pointer_type()
          && this->type_->points_to() != NULL))
-    return convert_to_pointer(this->type_->get_tree(gogo), expr_tree);
+    return convert_to_pointer(type_to_tree(this->type_->get_backend(gogo)),
+                             expr_tree);
   else if (expr_type->is_unsafe_pointer_type()
           && this->type_->integer_type() != NULL)
-    return convert_to_integer(this->type_->get_tree(gogo), expr_tree);
+    return convert_to_integer(type_to_tree(this->type_->get_backend(gogo)),
+                             expr_tree);
   else if (this->type_->interface_type() != NULL)
     return Expression::convert_interface_to_interface(context, this->type_,
                                                      this->expr_->type(),
@@ -12495,7 +12523,8 @@ Receive_expression::do_get_tree(Translate_context* context)
       return error_mark_node;
     }
   Type* element_type = channel_type->element_type();
-  tree element_type_tree = element_type->get_tree(context->gogo());
+  Btype* element_type_btype = element_type->get_backend(context->gogo());
+  tree element_type_tree = type_to_tree(element_type_btype);
 
   tree channel = this->channel_->get_tree(context);
   if (element_type_tree == error_mark_node || channel == error_mark_node)
@@ -12613,11 +12642,11 @@ Type_info_expression::do_type()
 tree
 Type_info_expression::do_get_tree(Translate_context* context)
 {
-  tree type_tree = this->type_->get_tree(context->gogo());
+  tree type_tree = type_to_tree(this->type_->get_backend(context->gogo()));
   if (type_tree == error_mark_node)
     return error_mark_node;
 
-  tree val_type_tree = this->type()->get_tree(context->gogo());
+  tree val_type_tree = type_to_tree(this->type()->get_backend(context->gogo()));
   go_assert(val_type_tree != error_mark_node);
 
   if (this->type_info_ == TYPE_INFO_SIZE)
@@ -12682,11 +12711,11 @@ class Struct_field_offset_expression : public Expression
 tree
 Struct_field_offset_expression::do_get_tree(Translate_context* context)
 {
-  tree type_tree = this->type_->get_tree(context->gogo());
+  tree type_tree = type_to_tree(this->type_->get_backend(context->gogo()));
   if (type_tree == error_mark_node)
     return error_mark_node;
 
-  tree val_type_tree = this->type()->get_tree(context->gogo());
+  tree val_type_tree = type_to_tree(this->type()->get_backend(context->gogo()));
   go_assert(val_type_tree != error_mark_node);
 
   const Struct_field_list* fields = this->type_->fields();
index 2ff94f6..7cd7511 100644 (file)
@@ -909,10 +909,13 @@ Named_object::get_tree(Gogo* gogo, Named_object* function)
            Type* type = named_constant->type();
            if (type != NULL && !type->is_abstract())
              {
-               if (!type->is_error())
-                 expr_tree = fold_convert(type->get_tree(gogo), expr_tree);
-               else
+               if (type->is_error())
                  expr_tree = error_mark_node;
+               else
+                 {
+                   Btype* btype = type->get_backend(gogo);
+                   expr_tree = fold_convert(type_to_tree(btype), expr_tree);
+                 }
              }
            if (expr_tree == error_mark_node)
              decl = error_mark_node;
@@ -939,7 +942,7 @@ Named_object::get_tree(Gogo* gogo, Named_object* function)
     case NAMED_OBJECT_TYPE:
       {
        Named_type* named_type = this->u_.type_value;
-       tree type_tree = named_type->get_tree(gogo);
+       tree type_tree = type_to_tree(named_type->get_backend(gogo));
        if (type_tree == error_mark_node)
          decl = error_mark_node;
        else
@@ -1104,7 +1107,7 @@ Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
 {
   if (this->fndecl_ == NULL_TREE)
     {
-      tree functype = this->type_->get_tree(gogo);
+      tree functype = type_to_tree(this->type_->get_backend(gogo));
       if (functype == error_mark_node)
        this->fndecl_ = error_mark_node;
       else
@@ -1217,7 +1220,7 @@ Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
            }
        }
 
-      tree functype = this->fntype_->get_tree(gogo);
+      tree functype = type_to_tree(this->fntype_->get_backend(gogo));
       tree decl;
       if (functype == error_mark_node)
        decl = error_mark_node;
@@ -1424,7 +1427,7 @@ Function::build_tree(Gogo* gogo, Named_object* named_function)
          else
            {
              source_location loc = (*p)->location();
-             tree type_tree = type->get_tree(gogo);
+             tree type_tree = type_to_tree(type->get_backend(gogo));
              tree space = gogo->allocate_memory(type,
                                                 TYPE_SIZE_UNIT(type_tree),
                                                 loc);
@@ -1712,7 +1715,7 @@ go_type_for_size(unsigned int bits, int unsignedp)
        return NULL_TREE;
     }
   Type* type = Type::lookup_integer_type(name);
-  return type->get_tree(go_get_gogo());
+  return type_to_tree(type->get_backend(go_get_gogo()));
 }
 
 // Return the type to use for a mode.
@@ -1743,7 +1746,7 @@ go_type_for_mode(enum machine_mode mode, int unsignedp)
            return long_double_type_node;
          return NULL_TREE;
        }
-      return type->get_tree(go_get_gogo());
+      return type_to_tree(type->get_backend(go_get_gogo()));
     }
   else if (mc == MODE_COMPLEX_FLOAT)
     {
@@ -1763,7 +1766,7 @@ go_type_for_mode(enum machine_mode mode, int unsignedp)
            return complex_long_double_type_node;
          return NULL_TREE;
        }
-      return type->get_tree(go_get_gogo());
+      return type_to_tree(type->get_backend(go_get_gogo()));
     }
   else
     return NULL_TREE;
@@ -1887,7 +1890,7 @@ Gogo::string_constant_tree(const std::string& val)
 tree
 Gogo::go_string_constant_tree(const std::string& val)
 {
-  tree string_type = Type::make_string_type()->get_tree(this);
+  tree string_type = type_to_tree(Type::make_string_type()->get_backend(this));
 
   VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
 
@@ -2016,13 +2019,15 @@ Gogo::map_descriptor(Map_type* maptype)
 
   tree map_entry_type = make_node(RECORD_TYPE);
 
+  Btype* bkey_type = keytype->get_backend(this);
+  Btype* bval_type = valtype->get_backend(this);
   map_entry_type = Gogo::builtin_struct(NULL, "__map", map_entry_type, 3,
                                        "__next",
                                        build_pointer_type(map_entry_type),
                                        "__key",
-                                       keytype->get_tree(this),
+                                       type_to_tree(bkey_type),
                                        "__val",
-                                       valtype->get_tree(this));
+                                       type_to_tree(bval_type));
   if (map_entry_type == error_mark_node)
     {
       p->second = error_mark_node;
@@ -2097,7 +2102,8 @@ tree
 Gogo::map_descriptor_type()
 {
   static tree struct_type;
-  tree dtype = Type::make_type_descriptor_type()->get_tree(this);
+  Type* tdt = Type::make_type_descriptor_type();
+  tree dtype = type_to_tree(tdt->get_backend(this));
   dtype = build_qualified_type(dtype, TYPE_QUAL_CONST);
   return Gogo::builtin_struct(&struct_type, "__go_map_descriptor", NULL_TREE,
                              4,
@@ -2238,7 +2244,8 @@ Gogo::build_type_descriptor_decl(const Type* type, Expression* initializer,
     decl_name = this->type_descriptor_decl_name(name->named_object(),
                                                name->in_function());
   tree id = get_identifier_from_string(decl_name);
-  tree descriptor_type_tree = initializer->type()->get_tree(this);
+  Type* init_type = initializer->type();
+  tree descriptor_type_tree = type_to_tree(init_type->get_backend(this));
   if (descriptor_type_tree == error_mark_node)
     {
       *pdecl = error_mark_node;
index c0dd988..7d1dd70 100644 (file)
@@ -3703,7 +3703,7 @@ Variable::get_backend_variable(Gogo* gogo, Named_object* function,
            }
 
          std::string n = Gogo::unpack_hidden_name(name);
-         Btype* btype = tree_to_type(type->get_tree(gogo));
+         Btype* btype = type->get_backend(gogo);
 
          Bvariable* bvar;
          if (this->is_global_)
@@ -3753,7 +3753,7 @@ Result_variable::get_backend_variable(Gogo* gogo, Named_object* function,
        {
          if (this->is_in_heap())
            type = Type::make_pointer_type(type);
-         Btype* btype = tree_to_type(type->get_tree(gogo));
+         Btype* btype = type->get_backend(gogo);
          tree fndecl = function->func_value()->get_decl();
          Bfunction* bfunction = tree_to_function(fndecl);
          std::string n = Gogo::unpack_hidden_name(name);
index 7e422fc..4fdf8f1 100644 (file)
@@ -375,7 +375,7 @@ Temporary_statement::do_get_backend(Translate_context* context)
   else
     bfunction = tree_to_function(function->func_value()->get_decl());
 
-  Btype* btype = tree_to_type(this->type()->get_tree(context->gogo()));
+  Btype* btype = this->type()->get_backend(context->gogo());
 
   Bexpression* binit;
   if (this->init_ == NULL)
index b89cb63..fdaf888 100644 (file)
@@ -37,7 +37,7 @@ extern "C"
 // Class Type.
 
 Type::Type(Type_classification classification)
-  : classification_(classification), tree_(NULL_TREE),
+  : classification_(classification), btype_(NULL),
     type_descriptor_decl_(NULL_TREE)
 {
 }
@@ -833,55 +833,56 @@ Type::check_int_value(Expression* e, const char* errmsg,
 
 // A hash table mapping unnamed types to trees.
 
-Type::Type_trees Type::type_trees;
+Type::Type_btypes Type::type_btypes;
 
 // Return a tree representing this type.
 
-tree
-Type::get_tree(Gogo* gogo)
+Btype*
+Type::get_backend(Gogo* gogo)
 {
-  if (this->tree_ != NULL)
-    return this->tree_;
+  if (this->btype_ != NULL)
+    return this->btype_;
 
   if (this->forward_declaration_type() != NULL
       || this->named_type() != NULL)
-    return type_to_tree(this->get_btype_without_hash(gogo));
+    return this->get_btype_without_hash(gogo);
 
   if (this->is_error_type())
-    return error_mark_node;
+    return gogo->backend()->error_type();
 
   // To avoid confusing the backend, translate all identical Go types
-  // to the same backend type.  We use a hash table to do that.  There
-  // is no need to use the hash table for named types, as named types
-  // are only identical to themselves.
+  // to the same backend representation.  We use a hash table to do
+  // that.  There is no need to use the hash table for named types, as
+  // named types are only identical to themselves.
 
-  std::pair<Type*, tree> val(this, NULL);
-  std::pair<Type_trees::iterator, bool> ins =
-    Type::type_trees.insert(val);
-  if (!ins.second && ins.first->second != NULL_TREE)
+  std::pair<Type*, Btype*> val(this, NULL);
+  std::pair<Type_btypes::iterator, bool> ins =
+    Type::type_btypes.insert(val);
+  if (!ins.second && ins.first->second != NULL)
     {
       if (gogo != NULL && gogo->named_types_are_converted())
-       this->tree_ = ins.first->second;
+       this->btype_ = ins.first->second;
       return ins.first->second;
     }
 
-  tree t = type_to_tree(this->get_btype_without_hash(gogo));
+  Btype* bt = this->get_btype_without_hash(gogo);
 
-  if (ins.first->second == NULL_TREE)
-    ins.first->second = t;
+  if (ins.first->second == NULL)
+    ins.first->second = bt;
   else
     {
-      // We have already created a tree for this type.  This can
-      // happen when an unnamed type is defined using a named type
-      // which in turns uses an identical unnamed type.  Use the tree
-      // we created earlier and ignore the one we just built.
-      t = ins.first->second;
+      // We have already created a backend representation for this
+      // type.  This can happen when an unnamed type is defined using
+      // a named type which in turns uses an identical unnamed type.
+      // Use the tree we created earlier and ignore the one we just
+      // built.
+      bt = ins.first->second;
       if (gogo == NULL || !gogo->named_types_are_converted())
-       return t;
-      this->tree_ = t;
+       return bt;
+      this->btype_ = bt;
     }
 
-  return t;
+  return bt;
 }
 
 // Return the backend representation for a type without looking in the
@@ -891,9 +892,9 @@ Type::get_tree(Gogo* gogo)
 Btype*
 Type::get_btype_without_hash(Gogo* gogo)
 {
-  if (this->tree_ == NULL_TREE)
+  if (this->btype_ == NULL)
     {
-      Btype* bt = tree_to_type(this->do_get_tree(gogo));
+      Btype* bt = this->do_get_backend(gogo);
 
       // For a recursive function or pointer type, we will temporarily
       // return a circular pointer type during the recursion.  We
@@ -906,11 +907,9 @@ Type::get_btype_without_hash(Gogo* gogo)
       if (gogo == NULL || !gogo->named_types_are_converted())
        return bt;
 
-      tree t = type_to_tree(bt);
-      this->tree_ = t;
+      this->btype_ = bt;
     }
-
-  return tree_to_type(this->tree_);
+  return this->btype_;
 }
 
 // Return a tree representing a zero initialization for this type.
@@ -918,7 +917,7 @@ Type::get_btype_without_hash(Gogo* gogo)
 tree
 Type::get_init_tree(Gogo* gogo, bool is_clear)
 {
-  tree type_tree = this->get_tree(gogo);
+  tree type_tree = type_to_tree(this->get_backend(gogo));
   if (type_tree == error_mark_node)
     return error_mark_node;
   return this->do_get_init_tree(gogo, type_tree, is_clear);
@@ -1585,9 +1584,9 @@ class Error_type : public Type
   { }
 
  protected:
-  tree
-  do_get_tree(Gogo* gogo)
-  { return type_to_tree(gogo->backend()->error_type()); }
+  Btype*
+  do_get_backend(Gogo* gogo)
+  { return gogo->backend()->error_type(); }
 
   tree
   do_get_init_tree(Gogo*, tree, bool)
@@ -1623,12 +1622,9 @@ class Void_type : public Type
   { }
 
  protected:
-  tree
-  do_get_tree(Gogo* gogo)
-  {
-    Btype* btype = gogo->backend()->void_type();
-    return type_to_tree(btype);
-  }
+  Btype*
+  do_get_backend(Gogo* gogo)
+  { return gogo->backend()->void_type(); }
 
   tree
   do_get_init_tree(Gogo*, tree, bool)
@@ -1664,12 +1660,9 @@ class Boolean_type : public Type
   { }
 
  protected:
-  tree
-  do_get_tree(Gogo* gogo)
-  {
-    Btype* btype = gogo->backend()->bool_type();
-    return type_to_tree(btype);
-  }
+  Btype*
+  do_get_backend(Gogo* gogo)
+  { return gogo->backend()->bool_type(); }
 
   tree
   do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
@@ -1805,18 +1798,15 @@ Integer_type::do_hash_for_method(Gogo*) const
 
 // Convert an Integer_type to the backend representation.
 
-tree
-Integer_type::do_get_tree(Gogo* gogo)
+Btype*
+Integer_type::do_get_backend(Gogo* gogo)
 {
   if (this->is_abstract_)
     {
       go_assert(saw_errors());
-      return error_mark_node;
+      return gogo->backend()->error_type();
     }
-
-  Btype* btype = gogo->backend()->integer_type(this->is_unsigned_,
-                                              this->bits_);
-  return type_to_tree(btype);
+  return gogo->backend()->integer_type(this->is_unsigned_, this->bits_);
 }
 
 tree
@@ -1946,11 +1936,10 @@ Float_type::do_hash_for_method(Gogo*) const
 
 // Convert to the backend representation.
 
-tree
-Float_type::do_get_tree(Gogo* gogo)
+Btype*
+Float_type::do_get_backend(Gogo* gogo)
 {
-  Btype* btype = gogo->backend()->float_type(this->bits_);
-  return type_to_tree(btype);
+  return gogo->backend()->float_type(this->bits_);
 }
 
 tree
@@ -2083,10 +2072,10 @@ Complex_type::do_hash_for_method(Gogo*) const
 
 // Convert to the backend representation.
 
-tree
-Complex_type::do_get_tree(Gogo* gogo)
+Btype*
+Complex_type::do_get_backend(Gogo* gogo)
 {
-  return type_to_tree(gogo->backend()->complex_type(this->bits_));
+  return gogo->backend()->complex_type(this->bits_);
 }
 
 // Zero initializer.
@@ -2161,8 +2150,8 @@ Type::lookup_complex_type(const char* name)
 // Convert String_type to the backend representation.  A string is a
 // struct with two fields: a pointer to the characters and a length.
 
-tree
-String_type::do_get_tree(Gogo* gogo)
+Btype*
+String_type::do_get_backend(Gogo* gogo)
 {
   static Btype* backend_string_type;
   if (backend_string_type == NULL)
@@ -2172,17 +2161,17 @@ String_type::do_get_tree(Gogo* gogo)
       Type* b = gogo->lookup_global("byte")->type_value();
       Type* pb = Type::make_pointer_type(b);
       fields[0].name = "__data";
-      fields[0].btype = tree_to_type(pb->get_tree(gogo));
+      fields[0].btype = pb->get_backend(gogo);
       fields[0].location = UNKNOWN_LOCATION;
 
       Type* int_type = Type::lookup_integer_type("int");
       fields[1].name = "__length";
-      fields[1].btype = tree_to_type(int_type->get_tree(gogo));
+      fields[1].btype = int_type->get_backend(gogo);
       fields[1].location = UNKNOWN_LOCATION;
 
       backend_string_type = gogo->backend()->struct_type(fields);
     }
-  return type_to_tree(backend_string_type);
+  return backend_string_type;
 }
 
 // Return a tree for the length of STRING.
@@ -2316,8 +2305,8 @@ class Sink_type : public Type
   { }
 
  protected:
-  tree
-  do_get_tree(Gogo*)
+  Btype*
+  do_get_backend(Gogo*)
   { go_unreachable(); }
 
   tree
@@ -2601,8 +2590,8 @@ Function_type::do_hash_for_method(Gogo* gogo) const
 
 // Get the tree for a function type.
 
-tree
-Function_type::do_get_tree(Gogo* gogo)
+Btype*
+Function_type::do_get_backend(Gogo* gogo)
 {
   Backend::Btyped_identifier breceiver;
   if (this->receiver_ != NULL)
@@ -2614,7 +2603,7 @@ Function_type::do_get_tree(Gogo* gogo)
       Type* rtype = this->receiver_->type();
       if (rtype->points_to() == NULL)
        rtype = Type::make_pointer_type(rtype);
-      breceiver.btype = tree_to_type(rtype->get_tree(gogo));
+      breceiver.btype = rtype->get_backend(gogo);
       breceiver.location = this->receiver_->location();
     }
 
@@ -2628,7 +2617,7 @@ Function_type::do_get_tree(Gogo* gogo)
           ++p, ++i)
        {
          bparameters[i].name = Gogo::unpack_hidden_name(p->name());
-         bparameters[i].btype = tree_to_type(p->type()->get_tree(gogo));
+         bparameters[i].btype = p->type()->get_backend(gogo);
          bparameters[i].location = p->location();
        }
       go_assert(i == bparameters.size());
@@ -2644,15 +2633,14 @@ Function_type::do_get_tree(Gogo* gogo)
           ++p, ++i)
        {
          bresults[i].name = Gogo::unpack_hidden_name(p->name());
-         bresults[i].btype = tree_to_type(p->type()->get_tree(gogo));
+         bresults[i].btype = p->type()->get_backend(gogo);
          bresults[i].location = p->location();
        }
       go_assert(i == bresults.size());
     }
 
-  Btype* fntype = gogo->backend()->function_type(breceiver, bparameters,
-                                                bresults, this->location());
-  return type_to_tree(fntype);
+  return gogo->backend()->function_type(breceiver, bparameters, bresults,
+                                       this->location());
 }
 
 // Functions are initialized to NULL.
@@ -3060,12 +3048,11 @@ Pointer_type::do_hash_for_method(Gogo* gogo) const
 
 // The tree for a pointer type.
 
-tree
-Pointer_type::do_get_tree(Gogo* gogo)
+Btype*
+Pointer_type::do_get_backend(Gogo* gogo)
 {
-  Btype* to_btype = tree_to_type(this->to_type_->get_tree(gogo));
-  Btype* btype = gogo->backend()->pointer_type(to_btype);
-  return type_to_tree(btype);
+  Btype* to_btype = this->to_type_->get_backend(gogo);
+  return gogo->backend()->pointer_type(to_btype);
 }
 
 // Initialize a pointer type.
@@ -3217,12 +3204,9 @@ class Nil_type : public Type
   { }
 
  protected:
-  tree
-  do_get_tree(Gogo* gogo)
-  {
-    Btype* bt = gogo->backend()->pointer_type(gogo->backend()->void_type());
-    return type_to_tree(bt);
-  }
+  Btype*
+  do_get_backend(Gogo* gogo)
+  { return gogo->backend()->pointer_type(gogo->backend()->void_type()); }
 
   tree
   do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
@@ -3271,8 +3255,12 @@ class Call_multiple_result_type : public Type
     return false;
   }
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo* gogo)
+  {
+    go_assert(saw_errors());
+    return gogo->backend()->error_type();
+  }
 
   tree
   do_get_init_tree(Gogo*, tree, bool)
@@ -3301,21 +3289,6 @@ class Call_multiple_result_type : public Type
   Call_expression* call_;
 };
 
-// Return the tree for a call result.
-
-tree
-Call_multiple_result_type::do_get_tree(Gogo* gogo)
-{
-  Function_type* fntype = this->call_->get_function_type();
-  go_assert(fntype != NULL);
-  const Typed_identifier_list* results = fntype->results();
-  go_assert(results != NULL && results->size() > 1);
-  tree fntype_tree = fntype->get_tree(gogo);
-  if (fntype_tree == error_mark_node)
-    return error_mark_node;
-  return TREE_TYPE(fntype_tree);
-}
-
 // Make a call result type.
 
 Type*
@@ -3780,7 +3753,7 @@ get_backend_struct_fields(Gogo* gogo, const Struct_field_list* fields,
        ++p, ++i)
     {
       (*bfields)[i].name = Gogo::unpack_hidden_name(p->field_name());
-      (*bfields)[i].btype = tree_to_type(p->type()->get_tree(gogo));
+      (*bfields)[i].btype = p->type()->get_backend(gogo);
       (*bfields)[i].location = p->location();
     }
   go_assert(i == fields->size());
@@ -3788,13 +3761,12 @@ get_backend_struct_fields(Gogo* gogo, const Struct_field_list* fields,
 
 // Get the tree for a struct type.
 
-tree
-Struct_type::do_get_tree(Gogo* gogo)
+Btype*
+Struct_type::do_get_backend(Gogo* gogo)
 {
   std::vector<Backend::Btyped_identifier> bfields;
   get_backend_struct_fields(gogo, this->fields_, &bfields);
-  Btype* btype = gogo->backend()->struct_type(bfields);
-  return type_to_tree(btype);
+  return gogo->backend()->struct_type(bfields);
 }
 
 // Initialize struct fields.
@@ -4382,7 +4354,7 @@ Array_type::get_length_tree(Gogo* gogo)
            t = Type::lookup_integer_type("int");
          else if (t->is_abstract())
            t = t->make_non_abstract_type();
-         tree tt = t->get_tree(gogo);
+         tree tt = type_to_tree(t->get_backend(gogo));
          this->length_tree_ = Expression::integer_constant_tree(val, tt);
          mpz_clear(val);
        }
@@ -4420,7 +4392,7 @@ get_backend_slice_fields(Gogo* gogo, Array_type* type,
   bfields->resize(3);
 
   Type* pet = Type::make_pointer_type(type->element_type());
-  Btype* pbet = tree_to_type(pet->get_tree(gogo));
+  Btype* pbet = pet->get_backend(gogo);
 
   Backend::Btyped_identifier* p = &(*bfields)[0];
   p->name = "__values";
@@ -4431,12 +4403,12 @@ get_backend_slice_fields(Gogo* gogo, Array_type* type,
 
   p = &(*bfields)[1];
   p->name = "__count";
-  p->btype = tree_to_type(int_type->get_tree(gogo));
+  p->btype = int_type->get_backend(gogo);
   p->location = UNKNOWN_LOCATION;
 
   p = &(*bfields)[2];
   p->name = "__capacity";
-  p->btype = tree_to_type(int_type->get_tree(gogo));
+  p->btype = int_type->get_backend(gogo);
   p->location = UNKNOWN_LOCATION;
 }
 
@@ -4445,21 +4417,20 @@ get_backend_slice_fields(Gogo* gogo, Array_type* type,
 // just like an array in C.  An open array is a struct with three
 // fields: a data pointer, the length, and the capacity.
 
-tree
-Array_type::do_get_tree(Gogo* gogo)
+Btype*
+Array_type::do_get_backend(Gogo* gogo)
 {
   if (this->length_ == NULL)
     {
       std::vector<Backend::Btyped_identifier> bfields;
       get_backend_slice_fields(gogo, this, &bfields);
-      return type_to_tree(gogo->backend()->struct_type(bfields));
+      return gogo->backend()->struct_type(bfields);
     }
   else
     {
       Btype* element = this->get_backend_element(gogo);
       Bexpression* len = this->get_backend_length(gogo);
-      Btype* ret = gogo->backend()->array_type(element, len);
-      return type_to_tree(ret);
+      return gogo->backend()->array_type(element, len);
     }
 }
 
@@ -4467,7 +4438,7 @@ Array_type::do_get_tree(Gogo* gogo)
 Btype*
 Array_type::get_backend_element(Gogo* gogo)
 {
-  return tree_to_type(this->element_type_->get_tree(gogo));
+  return this->element_type_->get_backend(gogo);
 }
 
 // Return the backend representation of the length.
@@ -4543,7 +4514,7 @@ Array_type::do_make_expression_tree(Translate_context* context,
   go_assert(this->length_ == NULL);
 
   Gogo* gogo = context->gogo();
-  tree type_tree = this->get_tree(gogo);
+  tree type_tree = type_to_tree(this->get_backend(gogo));
   if (type_tree == error_mark_node)
     return error_mark_node;
 
@@ -4555,7 +4526,7 @@ Array_type::do_make_expression_tree(Translate_context* context,
   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(count_field)),
                    "__count") == 0);
 
-  tree element_type_tree = this->element_type_->get_tree(gogo);
+  tree element_type_tree = type_to_tree(this->element_type_->get_backend(gogo));
   if (element_type_tree == error_mark_node)
     return error_mark_node;
   tree element_size_tree = TYPE_SIZE_UNIT(element_type_tree);
@@ -5061,8 +5032,8 @@ Map_type::do_check_make_expression(Expression_list* args,
 // represented as a pointer to a struct.  The struct is __go_map in
 // libgo/map.h.
 
-tree
-Map_type::do_get_tree(Gogo* gogo)
+Btype*
+Map_type::do_get_backend(Gogo* gogo)
 {
   static Btype* backend_map_type;
   if (backend_map_type == NULL)
@@ -5071,12 +5042,12 @@ Map_type::do_get_tree(Gogo* gogo)
 
       Type* pdt = Type::make_type_descriptor_ptr_type();
       bfields[0].name = "__descriptor";
-      bfields[0].btype = tree_to_type(pdt->get_tree(gogo));
+      bfields[0].btype = pdt->get_backend(gogo);
       bfields[0].location = BUILTINS_LOCATION;
 
       Type* uintptr_type = Type::lookup_integer_type("uintptr");
       bfields[1].name = "__element_count";
-      bfields[1].btype = tree_to_type(uintptr_type->get_tree(gogo));
+      bfields[1].btype = uintptr_type->get_backend(gogo);
       bfields[1].location = BUILTINS_LOCATION;
 
       bfields[2].name = "__bucket_count";
@@ -5094,7 +5065,7 @@ Map_type::do_get_tree(Gogo* gogo)
       bt = gogo->backend()->named_type("__go_map", bt, BUILTINS_LOCATION);
       backend_map_type = gogo->backend()->pointer_type(bt);
     }
-  return type_to_tree(backend_map_type);
+  return backend_map_type;
 }
 
 // Initialize a map.
@@ -5132,7 +5103,7 @@ Map_type::do_make_expression_tree(Translate_context* context,
                                           location);
     }
 
-  tree map_type = this->get_tree(context->gogo());
+  tree map_type = type_to_tree(this->get_backend(context->gogo()));
 
   static tree new_map_fndecl;
   tree ret = Gogo::call_builtin(&new_map_fndecl,
@@ -5329,8 +5300,8 @@ Channel_type::do_check_make_expression(Expression_list* args,
 // __go_channel struct.  The __go_channel struct is defined in
 // libgo/runtime/channel.h.
 
-tree
-Channel_type::do_get_tree(Gogo* gogo)
+Btype*
+Channel_type::do_get_backend(Gogo* gogo)
 {
   static Btype* backend_channel_type;
   if (backend_channel_type == NULL)
@@ -5340,7 +5311,7 @@ Channel_type::do_get_tree(Gogo* gogo)
       bt = gogo->backend()->named_type("__go_channel", bt, BUILTINS_LOCATION);
       backend_channel_type = gogo->backend()->pointer_type(bt);
     }
-  return type_to_tree(backend_channel_type);
+  return backend_channel_type;
 }
 
 // Initialize a channel variable.
@@ -5361,9 +5332,9 @@ Channel_type::do_make_expression_tree(Translate_context* context,
                                      source_location location)
 {
   Gogo* gogo = context->gogo();
-  tree channel_type = this->get_tree(gogo);
+  tree channel_type = type_to_tree(this->get_backend(gogo));
 
-  tree element_tree = this->element_type_->get_tree(gogo);
+  tree element_tree = type_to_tree(this->element_type_->get_backend(gogo));
   tree element_size_tree = size_in_bytes(element_tree);
 
   tree bad_index = NULL_TREE;
@@ -6003,12 +5974,12 @@ Interface_type::get_backend_empty_interface_type(Gogo* gogo)
 
       Type* pdt = Type::make_type_descriptor_ptr_type();
       bfields[0].name = "__type_descriptor";
-      bfields[0].btype = tree_to_type(pdt->get_tree(gogo));
+      bfields[0].btype = pdt->get_backend(gogo);
       bfields[0].location = UNKNOWN_LOCATION;
 
       Type* vt = Type::make_pointer_type(Type::make_void_type());
       bfields[1].name = "__object";
-      bfields[1].btype = tree_to_type(vt->get_tree(gogo));
+      bfields[1].btype = vt->get_backend(gogo);
       bfields[1].location = UNKNOWN_LOCATION;
 
       empty_interface_type = gogo->backend()->struct_type(bfields);
@@ -6030,7 +6001,7 @@ get_backend_interface_fields(Gogo* gogo, Interface_type* type,
 
   Type* pdt = Type::make_type_descriptor_ptr_type();
   mfields[0].name = "__type_descriptor";
-  mfields[0].btype = tree_to_type(pdt->get_tree(gogo));
+  mfields[0].btype = pdt->get_backend(gogo);
   mfields[0].location = loc;
 
   std::string last_name = "";
@@ -6040,7 +6011,7 @@ get_backend_interface_fields(Gogo* gogo, Interface_type* type,
        ++p, ++i)
     {
       mfields[i].name = Gogo::unpack_hidden_name(p->name());
-      mfields[i].btype = tree_to_type(p->type()->get_tree(gogo));
+      mfields[i].btype = p->type()->get_backend(gogo);
       mfields[i].location = loc;
       // Sanity check: the names should be sorted.
       go_assert(p->name() > last_name);
@@ -6057,7 +6028,7 @@ get_backend_interface_fields(Gogo* gogo, Interface_type* type,
 
   Type* vt = Type::make_pointer_type(Type::make_void_type());
   (*bfields)[1].name = "__object";
-  (*bfields)[1].btype = tree_to_type(vt->get_tree(gogo));
+  (*bfields)[1].btype = vt->get_backend(gogo);
   (*bfields)[1].location = UNKNOWN_LOCATION;
 }
 
@@ -6068,20 +6039,16 @@ get_backend_interface_fields(Gogo* gogo, Interface_type* type,
 // interface to be used with the object.  The third field is the value
 // of the object itself.
 
-tree
-Interface_type::do_get_tree(Gogo* gogo)
+Btype*
+Interface_type::do_get_backend(Gogo* gogo)
 {
   if (this->methods_ == NULL)
-    {
-      Btype* bt = Interface_type::get_backend_empty_interface_type(gogo);
-      return type_to_tree(bt);
-    }
+    return Interface_type::get_backend_empty_interface_type(gogo);
   else
     {
       std::vector<Backend::Btyped_identifier> bfields;
       get_backend_interface_fields(gogo, this, &bfields);
-      Btype* bt = gogo->backend()->struct_type(bfields);
-      return type_to_tree(bt);
+      return gogo->backend()->struct_type(bfields);
     }
 }
 
@@ -7200,11 +7167,11 @@ Named_type::create_placeholder(Gogo* gogo)
 
 // Get a tree for a named type.
 
-tree
-Named_type::do_get_tree(Gogo* gogo)
+Btype*
+Named_type::do_get_backend(Gogo* gogo)
 {
   if (this->is_error_)
-    return error_mark_node;
+    return gogo->backend()->error_type();
 
   Btype* bt = this->named_btype_;
 
@@ -7213,7 +7180,7 @@ Named_type::do_get_tree(Gogo* gogo)
       // We have not completed converting named types.  NAMED_BTYPE_
       // is a placeholder and we shouldn't do anything further.
       if (bt != NULL)
-       return type_to_tree(bt);
+       return bt;
 
       // We don't build dependencies for types whose sizes do not
       // change or are not relevant, so we may see them here while
@@ -7221,7 +7188,7 @@ Named_type::do_get_tree(Gogo* gogo)
       this->create_placeholder(gogo);
       bt = this->named_btype_;
       go_assert(bt != NULL);
-      return type_to_tree(bt);
+      return bt;
     }
 
   // We are not converting types.  This should only be called if the
@@ -7229,7 +7196,7 @@ Named_type::do_get_tree(Gogo* gogo)
   if (!this->is_converted_)
     {
       go_assert(saw_errors());
-      return error_mark_node;
+      return gogo->backend()->error_type();
     }
 
   go_assert(bt != NULL);
@@ -7240,7 +7207,7 @@ Named_type::do_get_tree(Gogo* gogo)
   switch (base->classification())
     {
     case TYPE_ERROR:
-      return error_mark_node;
+      return gogo->backend()->error_type();
 
     case TYPE_VOID:
     case TYPE_BOOLEAN:
@@ -7254,7 +7221,7 @@ Named_type::do_get_tree(Gogo* gogo)
     case TYPE_STRUCT:
     case TYPE_ARRAY:
     case TYPE_INTERFACE:
-      return type_to_tree(bt);
+      return bt;
 
     case TYPE_FUNCTION:
       // Don't build a circular data structure.  GENERIC can't handle
@@ -7262,8 +7229,7 @@ Named_type::do_get_tree(Gogo* gogo)
       if (this->seen_ > 0)
        {
          this->is_circular_ = true;
-         bt1 = gogo->backend()->circular_pointer_type(bt, true);
-         return type_to_tree(bt1);
+         return gogo->backend()->circular_pointer_type(bt, true);
        }
       ++this->seen_;
       bt1 = Type::get_named_base_btype(gogo, base);
@@ -7272,7 +7238,7 @@ Named_type::do_get_tree(Gogo* gogo)
        bt1 = gogo->backend()->circular_pointer_type(bt, true);
       if (!gogo->backend()->set_placeholder_pointer_type(bt, bt1))
        bt = gogo->backend()->error_type();
-      return type_to_tree(bt);
+      return bt;
 
     case TYPE_POINTER:
       // Don't build a circular data structure. GENERIC can't handle
@@ -7280,8 +7246,7 @@ Named_type::do_get_tree(Gogo* gogo)
       if (this->seen_ > 0)
        {
          this->is_circular_ = true;
-         bt1 = gogo->backend()->circular_pointer_type(bt, false);
-         return type_to_tree(bt1);
+         return gogo->backend()->circular_pointer_type(bt, false);
        }
       ++this->seen_;
       bt1 = Type::get_named_base_btype(gogo, base);
@@ -7290,7 +7255,7 @@ Named_type::do_get_tree(Gogo* gogo)
        bt1 = gogo->backend()->circular_pointer_type(bt, false);
       if (!gogo->backend()->set_placeholder_pointer_type(bt, bt1))
        bt = gogo->backend()->error_type();
-      return type_to_tree(bt);
+      return bt;
 
     default:
     case TYPE_SINK:
@@ -8409,23 +8374,22 @@ Forward_declaration_type::do_traverse(Traverse* traverse)
 
 // Get the backend representation for the type.
 
-tree
-Forward_declaration_type::do_get_tree(Gogo* gogo)
+Btype*
+Forward_declaration_type::do_get_backend(Gogo* gogo)
 {
   if (this->is_defined())
-    return type_to_tree(Type::get_named_base_btype(gogo, this->real_type()));
+    return Type::get_named_base_btype(gogo, this->real_type());
 
   if (this->warned_)
-    return error_mark_node;
+    return gogo->backend()->error_type();
 
   // We represent an undefined type as a struct with no fields.  That
   // should work fine for the backend, since the same case can arise
   // in C.
   std::vector<Backend::Btyped_identifier> fields;
   Btype* bt = gogo->backend()->struct_type(fields);
-  bt = gogo->backend()->named_type(this->name(), bt,
-                                  this->named_object()->location());
-  return type_to_tree(bt);
+  return gogo->backend()->named_type(this->name(), bt,
+                                    this->named_object()->location());
 }
 
 // Build a type descriptor for a forwarded type.
index a76b653..74dad7b 100644 (file)
@@ -821,9 +821,9 @@ class Type
   static void
   convert_builtin_named_types(Gogo*);
 
-  // Return a tree representing this type.
-  tree
-  get_tree(Gogo*);
+  // Return the backend representation of this type.
+  Btype*
+  get_backend(Gogo*);
 
   // Return a tree representing a zero initialization for this type.
   // This will be something like an INTEGER_CST or a CONSTRUCTOR.  If
@@ -892,9 +892,8 @@ class Type
   virtual bool
   do_check_make_expression(Expression_list* args, source_location);
 
-
-  virtual tree
-  do_get_tree(Gogo*) = 0;
+  virtual Btype*
+  do_get_backend(Gogo*) = 0;
 
   virtual tree
   do_get_init_tree(Gogo*, tree, bool) = 0;
@@ -1103,20 +1102,21 @@ class Type
   Btype*
   get_btype_without_hash(Gogo*);
 
-  // A mapping from Type to tree, used to ensure that the GIMPLE
+  // A mapping from Type to Btype*, used to ensure that the backend
   // representation of identical types is identical.
-  typedef Unordered_map_hash(const Type*, tree, Type_hash_identical,
-                            Type_identical) Type_trees;
+  typedef Unordered_map_hash(const Type*, Btype*, Type_hash_identical,
+                            Type_identical) Type_btypes;
 
-  static Type_trees type_trees;
+  static Type_btypes type_btypes;
 
   // A list of builtin named types.
   static std::vector<Named_type*> named_builtin_types;
 
   // The type classification.
   Type_classification classification_;
-  // The tree representation of the type, once it has been determined.
-  tree tree_;
+  // The backend representation of the type, once it has been
+  // determined.
+  Btype* btype_;
   // The decl for the type descriptor for this type.  This starts out
   // as NULL and is filled in as needed.
   tree type_descriptor_decl_;
@@ -1331,8 +1331,8 @@ class Integer_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -1403,8 +1403,8 @@ class Float_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -1471,8 +1471,8 @@ class Complex_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -1527,8 +1527,8 @@ class String_type : public Type
   do_has_pointer() const
   { return true; }
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo* gogo, tree, bool);
@@ -1643,8 +1643,8 @@ class Function_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -1717,8 +1717,8 @@ class Pointer_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -1971,8 +1971,8 @@ class Struct_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -2088,8 +2088,8 @@ class Array_type : public Type
   bool
   do_check_make_expression(Expression_list*, source_location);
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -2179,8 +2179,8 @@ class Map_type : public Type
   bool
   do_check_make_expression(Expression_list*, source_location);
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -2263,8 +2263,8 @@ class Channel_type : public Type
   bool
   do_check_make_expression(Expression_list*, source_location);
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo*, tree, bool);
@@ -2381,8 +2381,8 @@ class Interface_type : public Type
   unsigned int
   do_hash_for_method(Gogo*) const;
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo* gogo, tree, bool);
@@ -2612,8 +2612,8 @@ class Named_type : public Type
   do_check_make_expression(Expression_list* args, source_location location)
   { return this->type_->check_make_expression(args, location); }
 
-  tree
-  do_get_tree(Gogo*);
+  Btype*
+  do_get_backend(Gogo*);
 
   tree
   do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
@@ -2756,8 +2756,8 @@ class Forward_declaration_type : public Type
   do_check_make_expression(Expression_list* args, source_location location)
   { return this->base()->check_make_expression(args, location); }
 
-  tree
-  do_get_tree(Gogo* gogo);
+  Btype*
+  do_get_backend(Gogo* gogo);
 
   tree
   do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)