+// Get the backend representation of a type without forcing the
+// creation of the backend representation of all supporting types.
+// This will return a backend type that has the correct size but may
+// be incomplete. E.g., a pointer will just be a placeholder pointer,
+// and will not contain the final representation of the type to which
+// it points. This is used while converting all named types to the
+// backend representation, to avoid problems with indirect references
+// to types which are not yet complete. When this is called, the
+// sizes of all direct references (e.g., a struct field) should be
+// known, but the sizes of indirect references (e.g., the type to
+// which a pointer points) may not.
+
+Btype*
+Type::get_backend_placeholder(Gogo* gogo)
+{
+ if (gogo->named_types_are_converted())
+ return this->get_backend(gogo);
+ if (this->btype_ != NULL)
+ return this->btype_;
+
+ Btype* bt;
+ switch (this->classification_)
+ {
+ case TYPE_ERROR:
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These are simple types that can just be created directly.
+ return this->get_backend(gogo);
+
+ case TYPE_FUNCTION:
+ {
+ Location loc = this->function_type()->location();
+ bt = gogo->backend()->placeholder_pointer_type("", loc, true);
+ }
+ break;
+
+ case TYPE_POINTER:
+ {
+ Location loc = Linemap::unknown_location();
+ bt = gogo->backend()->placeholder_pointer_type("", loc, false);
+ }
+ break;
+
+ case TYPE_STRUCT:
+ // We don't have to make the struct itself be a placeholder. We
+ // are promised that we know the sizes of the struct fields.
+ // But we may have to use a placeholder for any particular
+ // struct field.
+ {
+ std::vector<Backend::Btyped_identifier> bfields;
+ get_backend_struct_fields(gogo, this->struct_type()->fields(),
+ true, &bfields);
+ bt = gogo->backend()->struct_type(bfields);
+ }
+ break;
+
+ case TYPE_ARRAY:
+ if (this->is_slice_type())
+ {
+ std::vector<Backend::Btyped_identifier> bfields;
+ get_backend_slice_fields(gogo, this->array_type(), true, &bfields);
+ bt = gogo->backend()->struct_type(bfields);
+ }
+ else
+ {
+ Btype* element = this->array_type()->get_backend_element(gogo, true);
+ Bexpression* len = this->array_type()->get_backend_length(gogo);
+ bt = gogo->backend()->array_type(element, len);
+ }
+ break;
+
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ // All maps and channels have the same backend representation.
+ return this->get_backend(gogo);
+
+ case TYPE_INTERFACE:
+ if (this->interface_type()->is_empty())
+ return Interface_type::get_backend_empty_interface_type(gogo);
+ else
+ {
+ std::vector<Backend::Btyped_identifier> bfields;
+ get_backend_interface_fields(gogo, this->interface_type(), true,
+ &bfields);
+ bt = gogo->backend()->struct_type(bfields);
+ }
+ break;
+
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ // Named types keep track of their own dependencies and manage
+ // their own placeholders.
+ return this->get_backend(gogo);
+
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ default:
+ go_unreachable();
+ }
+
+ this->btype_ = bt;
+ this->btype_is_placeholder_ = true;
+ return bt;
+}
+
+// Complete the backend representation. This is called for a type
+// using a placeholder type.
+
+void
+Type::finish_backend(Gogo* gogo)
+{
+ go_assert(this->btype_ != NULL);
+ if (!this->btype_is_placeholder_)
+ return;
+
+ switch (this->classification_)
+ {
+ case TYPE_ERROR:
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ go_unreachable();
+
+ case TYPE_FUNCTION:
+ {
+ Btype* bt = this->do_get_backend(gogo);
+ if (!gogo->backend()->set_placeholder_function_type(this->btype_, bt))
+ go_assert(saw_errors());
+ }
+ break;
+
+ case TYPE_POINTER:
+ {
+ Btype* bt = this->do_get_backend(gogo);
+ if (!gogo->backend()->set_placeholder_pointer_type(this->btype_, bt))
+ go_assert(saw_errors());
+ }
+ break;
+
+ case TYPE_STRUCT:
+ // The struct type itself is done, but we have to make sure that
+ // all the field types are converted.
+ this->struct_type()->finish_backend_fields(gogo);
+ break;
+
+ case TYPE_ARRAY:
+ // The array type itself is done, but make sure the element type
+ // is converted.
+ this->array_type()->finish_backend_element(gogo);
+ break;
+
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ go_unreachable();
+
+ case TYPE_INTERFACE:
+ // The interface type itself is done, but make sure the method
+ // types are converted.
+ this->interface_type()->finish_backend_methods(gogo);
+ break;
+
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ go_unreachable();
+
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ default:
+ go_unreachable();
+ }
+
+ this->btype_is_placeholder_ = false;
+}
+