compiler: list indirect imports separately in export data
Previously when export data referred to a type that was not defined in
a directly imported package, we would write the package name as
additional information in the type's export data. That approach
required all type information to be read in order. This patch changes
the compiler to find all references to indirectly imported packages,
and write them out as an indirectimport line in the import data. This
will permit us to read exported type data out of order.
The type traversal used to find indirect imports is a little more
complicated than necessary in preparation for later patches in this
series.
Change-Id: Ie50fe23509ebf858b738dd109f733b08ed535dcd
Reviewed-on: https://go-review.googlesource.com/c/143020
Reviewed-by: Than McIntosh <thanm@google.com>
diff --git a/go/export.cc b/go/export.cc
index db57ab5..da3d67f 100644
--- a/go/export.cc
+++ b/go/export.cc
@@ -143,6 +143,10 @@
std::sort(exports.begin(), exports.end(), Sort_bindings());
+ // Find all packages not explicitly imported but mentioned by types.
+ Unordered_set(const Package*) type_imports;
+ this->prepare_types(&exports, &type_imports);
+
// Although the export data is readable, at least this version is,
// it is conceptually a binary format. Start with a four byte
// version number.
@@ -169,7 +173,7 @@
this->write_packages(packages);
- this->write_imports(imports);
+ this->write_imports(imports, type_imports);
this->write_imported_init_fns(package_name, import_init_fn,
imported_init_fns);
@@ -199,6 +203,179 @@
this->stream_->write_checksum(s);
}
+// Traversal class to find referenced types.
+
+class Find_types_to_prepare : public Traverse
+{
+ public:
+ Find_types_to_prepare(Unordered_set(const Package*)* imports)
+ : Traverse(traverse_types),
+ imports_(imports)
+ { }
+
+ int
+ type(Type* type);
+
+ // Traverse the components of a function type.
+ void
+ traverse_function(Function_type*);
+
+ // Traverse the methods of a named type, and register its package.
+ void
+ traverse_named_type(Named_type*);
+
+ private:
+ // List of packages we are building.
+ Unordered_set(const Package*)* imports_;
+};
+
+// Traverse a type.
+
+int
+Find_types_to_prepare::type(Type* type)
+{
+ // Skip forwarders.
+ if (type->forward_declaration_type() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ // At this stage of compilation traversing interface types traverses
+ // the final list of methods, but we export the locally defined
+ // methods. If there is an embedded interface type we need to make
+ // sure to export that. Check classification, rather than calling
+ // the interface_type method, because we want to handle named types
+ // below.
+ if (type->classification() == Type::TYPE_INTERFACE)
+ {
+ Interface_type* it = type->interface_type();
+ const Typed_identifier_list* methods = it->local_methods();
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->name().empty())
+ Type::traverse(p->type(), this);
+ else
+ this->traverse_function(p->type()->function_type());
+ }
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ Named_type* nt = type->named_type();
+ if (nt != NULL)
+ this->traverse_named_type(nt);
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Traverse the types in a function type. We don't need the function
+// type tself, just the receiver, parameter, and result types.
+
+void
+Find_types_to_prepare::traverse_function(Function_type* type)
+{
+ go_assert(type != NULL);
+ if (this->remember_type(type))
+ return;
+ const Typed_identifier* receiver = type->receiver();
+ if (receiver != NULL)
+ Type::traverse(receiver->type(), this);
+ const Typed_identifier_list* parameters = type->parameters();
+ if (parameters != NULL)
+ parameters->traverse(this);
+ const Typed_identifier_list* results = type->results();
+ if (results != NULL)
+ results->traverse(this);
+}
+
+// Traverse the methods of a named type, and record its package.
+
+void
+Find_types_to_prepare::traverse_named_type(Named_type* nt)
+{
+ const Package* package = nt->named_object()->package();
+ if (package != NULL)
+ this->imports_->insert(package);
+
+ // We have to traverse the methods of named types, because we are
+ // going to export them. This is not done by ordinary type
+ // traversal.
+ const Bindings* methods = nt->local_methods();
+ if (methods != NULL)
+ {
+ for (Bindings::const_definitions_iterator pm =
+ methods->begin_definitions();
+ pm != methods->end_definitions();
+ ++pm)
+ this->traverse_function((*pm)->func_value()->type());
+
+ for (Bindings::const_declarations_iterator pm =
+ methods->begin_declarations();
+ pm != methods->end_declarations();
+ ++pm)
+ {
+ Named_object* mno = pm->second;
+ if (mno->is_function_declaration())
+ this->traverse_function(mno->func_declaration_value()->type());
+ }
+ }
+}
+
+// Collect all the pacakges we see in types, so that if we refer to
+// any types from indirectly importe packages we can tell the importer
+// about the package.
+
+void
+Export::prepare_types(const std::vector<Named_object*>* exports,
+ Unordered_set(const Package*)* imports)
+{
+ // Use a single index of the traversal class because traversal
+ // classes keep track of which types they've already seen. That
+ // lets us avoid type reference loops.
+ Find_types_to_prepare find(imports);
+
+ // Traverse all the exported objects.
+ for (std::vector<Named_object*>::const_iterator p = exports->begin();
+ p != exports->end();
+ ++p)
+ {
+ Named_object* no = *p;
+ switch (no->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ {
+ Type* t = no->const_value()->type();
+ if (t != NULL && !t->is_abstract())
+ Type::traverse(t, &find);
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ Type::traverse(no->type_value(), &find);
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ Type::traverse(no->var_value()->type(), &find);
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ find.traverse_function(no->func_value()->type());
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ find.traverse_function(no->func_declaration_value()->type());
+ break;
+
+ default:
+ // We shouldn't see anything else. If we do we'll give an
+ // error later when we try to actually export it.
+ break;
+ }
+ }
+}
+
// Sort packages.
static bool
@@ -253,14 +430,19 @@
// Write out the imported packages.
void
-Export::write_imports(const std::map<std::string, Package*>& imports)
+Export::write_imports(const std::map<std::string, Package*>& imports,
+ const Unordered_set(const Package*)& type_imports)
{
// Sort the imports for more consistent output.
+ Unordered_set(const Package*) seen;
std::vector<std::pair<std::string, Package*> > sorted_imports;
for (std::map<std::string, Package*>::const_iterator p = imports.begin();
p != imports.end();
++p)
- sorted_imports.push_back(std::make_pair(p->first, p->second));
+ {
+ sorted_imports.push_back(std::make_pair(p->first, p->second));
+ seen.insert(p->second);
+ }
std::sort(sorted_imports.begin(), sorted_imports.end(), import_compare);
@@ -279,6 +461,32 @@
this->packages_.insert(p->second);
}
+
+ // Write out a separate list of indirectly imported packages.
+ std::vector<const Package*> indirect_imports;
+ for (Unordered_set(const Package*)::const_iterator p =
+ type_imports.begin();
+ p != type_imports.end();
+ ++p)
+ {
+ if (seen.find(*p) == seen.end())
+ indirect_imports.push_back(*p);
+ }
+
+ std::sort(indirect_imports.begin(), indirect_imports.end(),
+ packages_compare);
+
+ for (std::vector<const Package*>::const_iterator p =
+ indirect_imports.begin();
+ p != indirect_imports.end();
+ ++p)
+ {
+ this->write_c_string("indirectimport ");
+ this->write_string((*p)->package_name());
+ this->write_c_string(" ");
+ this->write_string((*p)->pkgpath());
+ this->write_c_string("\n");
+ }
}
void
@@ -602,19 +810,6 @@
s += "\" ";
this->write_string(s);
- // It is possible that this type was imported indirectly, and is
- // not in a package in the import list. If we have not
- // mentioned this package before, write out the package name
- // here so that any package importing this one will know it.
- if (package != NULL
- && this->packages_.find(package) == this->packages_.end())
- {
- this->write_c_string("\"");
- this->write_string(package->package_name());
- this->packages_.insert(package);
- this->write_c_string("\" ");
- }
-
// We must add a named type to the table now, since the
// definition of the type may refer to the named type via a
// pointer.
diff --git a/go/export.h b/go/export.h
index b08bf85..5594281 100644
--- a/go/export.h
+++ b/go/export.h
@@ -12,6 +12,7 @@
class Go_sha1_helper;
class Gogo;
class Import_init;
+class Named_object;
class Bindings;
class Type;
class Package;
@@ -194,6 +195,11 @@
Export(const Export&);
Export& operator=(const Export&);
+ // Prepare types for exporting.
+ void
+ prepare_types(const std::vector<Named_object*>* exports,
+ Unordered_set(const Package*)* imports);
+
// Write out all known packages.
void
write_packages(const std::map<std::string, Package*>& packages);
@@ -210,7 +216,8 @@
// Write out the imported packages.
void
- write_imports(const std::map<std::string, Package*>& imports);
+ write_imports(const std::map<std::string, Package*>& imports,
+ const Unordered_set(const Package*)& type_imports);
// Write out the imported initialization functions and init graph.
void
diff --git a/go/import.cc b/go/import.cc
index ad30e6e..8d17df7 100644
--- a/go/import.cc
+++ b/go/import.cc
@@ -397,6 +397,9 @@
while (stream->match_c_string("import"))
this->read_one_import();
+ while (stream->match_c_string("indirectimport"))
+ this->read_one_indirect_import();
+
if (stream->match_c_string("init"))
this->read_import_init_fns(gogo);
@@ -458,7 +461,7 @@
p->set_package_name(package_name, this->location());
}
-// Read an import line. We don't actually care about these.
+// Read an import line.
void
Import::read_one_import()
@@ -480,6 +483,22 @@
p->set_package_name(package_name, this->location());
}
+// Read an indirectimport line.
+
+void
+Import::read_one_indirect_import()
+{
+ this->require_c_string("indirectimport ");
+ std::string package_name = this->read_identifier();
+ this->require_c_string(" ");
+ std::string pkgpath = this->read_identifier();
+ this->require_c_string("\n");
+
+ Package* p = this->gogo_->register_package(pkgpath, "",
+ Linemap::unknown_location());
+ p->set_package_name(package_name, this->location());
+}
+
// Read the list of import control functions and/or init graph.
void
diff --git a/go/import.h b/go/import.h
index 84f5fc7..dbdcc8f 100644
--- a/go/import.h
+++ b/go/import.h
@@ -241,6 +241,10 @@
void
read_one_import();
+ // Read an indirectimport line.
+ void
+ read_one_indirect_import();
+
// Read the import control functions and init graph.
void
read_import_init_fns(Gogo*);
diff --git a/go/types.cc b/go/types.cc
index e368ee0..e766c77 100644
--- a/go/types.cc
+++ b/go/types.cc
@@ -12113,7 +12113,7 @@
// Traverse types.
int
-Typed_identifier_list::traverse(Traverse* traverse)
+Typed_identifier_list::traverse(Traverse* traverse) const
{
for (Typed_identifier_list::const_iterator p = this->begin();
p != this->end();
diff --git a/go/types.h b/go/types.h
index 8d0faad..18cc257 100644
--- a/go/types.h
+++ b/go/types.h
@@ -1499,7 +1499,7 @@
// Traverse types.
int
- traverse(Traverse*);
+ traverse(Traverse*) const;
// Return the first and last elements.
Typed_identifier&
@@ -3056,8 +3056,15 @@
return this->all_methods_ == NULL;
}
- // Return the list of methods. This will return NULL for an empty
- // interface.
+ // Return the list of locally defined methos. This will return NULL
+ // for an empty interface. Embedded interfaces will appear in this
+ // list as an entry with no name.
+ const Typed_identifier_list*
+ local_methods() const
+ { return this->parse_methods_; }
+
+ // Return the list of all methods. This will return NULL for an
+ // empty interface.
const Typed_identifier_list*
methods() const;
diff --git a/libgo/go/go/internal/gccgoimporter/parser.go b/libgo/go/go/internal/gccgoimporter/parser.go
index 5988c5d..cd4e1d9 100644
--- a/libgo/go/go/internal/gccgoimporter/parser.go
+++ b/libgo/go/go/internal/gccgoimporter/parser.go
@@ -832,6 +832,7 @@
// "pkgpath" unquotedString ";" |
// "prefix" unquotedString ";" |
// "import" unquotedString unquotedString string ";" |
+// "indirectimport" unquotedString unquotedstring ";" |
// "func" Func ";" |
// "type" Type ";" |
// "var" Var ";" |
@@ -875,6 +876,13 @@
p.parseString()
p.expectEOL()
+ case "indirectimport":
+ p.next()
+ pkgname := p.parseUnquotedString()
+ pkgpath := p.parseUnquotedString()
+ p.getPkg(pkgpath, pkgname)
+ p.expectEOL()
+
case "func":
p.next()
fun := p.parseFunc(p.pkg)
