From dbf9376f9ed37bc98218adde4e17d6ee34701179 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 18 Oct 2018 23:22:01 +0000 Subject: [PATCH] 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. Reviewed-on: https://go-review.googlesource.com/c/143020 From-SVN: r265296 --- gcc/go/gofrontend/MERGE | 2 +- gcc/go/gofrontend/export.cc | 227 +++++++++++++++++-- gcc/go/gofrontend/export.h | 9 +- gcc/go/gofrontend/import.cc | 21 +- gcc/go/gofrontend/import.h | 4 + gcc/go/gofrontend/types.cc | 2 +- gcc/go/gofrontend/types.h | 13 +- libgo/go/go/internal/gccgoimporter/parser.go | 8 + 8 files changed, 263 insertions(+), 23 deletions(-) diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE index a2cf0af0634..28b39847bfa 100644 --- a/gcc/go/gofrontend/MERGE +++ b/gcc/go/gofrontend/MERGE @@ -1,4 +1,4 @@ -84531ef21230307773daa438a50bf095edcdbf93 +9c985ce6f76dd65b8eb0e4b03c09ad0100712e04 The first line of this file holds the git revision number of the last merge done from the gofrontend repository. diff --git a/gcc/go/gofrontend/export.cc b/gcc/go/gofrontend/export.cc index db57ab58850..da3d67f1152 100644 --- a/gcc/go/gofrontend/export.cc +++ b/gcc/go/gofrontend/export.cc @@ -143,6 +143,10 @@ Export::export_globals(const std::string& package_name, 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 @@ Export::export_globals(const std::string& package_name, 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 @@ Export::export_globals(const std::string& package_name, 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* 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::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 @@ import_compare(const std::pair& a, // Write out the imported packages. void -Export::write_imports(const std::map& imports) +Export::write_imports(const std::map& imports, + const Unordered_set(const Package*)& type_imports) { // Sort the imports for more consistent output. + Unordered_set(const Package*) seen; std::vector > sorted_imports; for (std::map::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 @@ Export::write_imports(const std::map& imports) this->packages_.insert(p->second); } + + // Write out a separate list of indirectly imported packages. + std::vector 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_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 @@ Export::write_type(const Type* type) 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/gcc/go/gofrontend/export.h b/gcc/go/gofrontend/export.h index b08bf851318..55942818eec 100644 --- a/gcc/go/gofrontend/export.h +++ b/gcc/go/gofrontend/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 @@ class Export : public String_dump Export(const Export&); Export& operator=(const Export&); + // Prepare types for exporting. + void + prepare_types(const std::vector* exports, + Unordered_set(const Package*)* imports); + // Write out all known packages. void write_packages(const std::map& packages); @@ -210,7 +216,8 @@ class Export : public String_dump // Write out the imported packages. void - write_imports(const std::map& imports); + write_imports(const std::map& imports, + const Unordered_set(const Package*)& type_imports); // Write out the imported initialization functions and init graph. void diff --git a/gcc/go/gofrontend/import.cc b/gcc/go/gofrontend/import.cc index ad30e6ee488..8d17df708fc 100644 --- a/gcc/go/gofrontend/import.cc +++ b/gcc/go/gofrontend/import.cc @@ -397,6 +397,9 @@ Import::import(Gogo* gogo, const std::string& local_name, 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 @@ Import::read_one_package() 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 @@ Import::read_one_import() 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/gcc/go/gofrontend/import.h b/gcc/go/gofrontend/import.h index 84f5fc7eb86..dbdcc8fb489 100644 --- a/gcc/go/gofrontend/import.h +++ b/gcc/go/gofrontend/import.h @@ -241,6 +241,10 @@ class Import 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/gcc/go/gofrontend/types.cc b/gcc/go/gofrontend/types.cc index e368ee0a754..e766c77ab0a 100644 --- a/gcc/go/gofrontend/types.cc +++ b/gcc/go/gofrontend/types.cc @@ -12113,7 +12113,7 @@ Typed_identifier_list::sort_by_name() // 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/gcc/go/gofrontend/types.h b/gcc/go/gofrontend/types.h index 8d0faad8b8c..18cc2575bf5 100644 --- a/gcc/go/gofrontend/types.h +++ b/gcc/go/gofrontend/types.h @@ -1499,7 +1499,7 @@ class Typed_identifier_list // Traverse types. int - traverse(Traverse*); + traverse(Traverse*) const; // Return the first and last elements. Typed_identifier& @@ -3056,8 +3056,15 @@ class Interface_type : public Type 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 5988c5d3673..cd4e1d9288e 100644 --- a/libgo/go/go/internal/gccgoimporter/parser.go +++ b/libgo/go/go/internal/gccgoimporter/parser.go @@ -832,6 +832,7 @@ func (p *parser) parseInitDataDirective() { // "pkgpath" unquotedString ";" | // "prefix" unquotedString ";" | // "import" unquotedString unquotedString string ";" | +// "indirectimport" unquotedString unquotedstring ";" | // "func" Func ";" | // "type" Type ";" | // "var" Var ";" | @@ -875,6 +876,13 @@ func (p *parser) parseDirective() { 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) -- 2.30.2