procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

compiler: add result parameter names for inlinable functions

Browse source 
An inlinable function body may need to refer to result parameters, so
    each result parameter needs a name.  We already give them all names in
    start_function (via create_result_variables).  Change the export data
    so that for an inlinable function we use those names for the function
    declaration's result parameters.
    
    Reviewed-on: https://go-review.googlesource.com/c/150070

From-SVN: r266532
This commit is contained in:
Ian Lance Taylor 2018-11-27 21:40:56 +00:00
parent 340632e97b
commit b07b067163
3 changed files with 32 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gcc/go/gofrontend/MERGE
View file

@ -1,4 +1,4 @@
21cf8069ceb078de54cc43ac25c9c89bd15cba56 5d0c788cd6099c2bb28bb0ff6a04d94006fbfca8
The first line of this file holds the git revision number of the last The first line of this file holds the git revision number of the last
merge done from the gofrontend repository. merge done from the gofrontend repository.

41
gcc/go/gofrontend/gogo.cc
View file

@ -5487,7 +5487,7 @@ Function::export_func(Export* exp, const std::string& name) const
Block* block = NULL; Block* block = NULL;
if (this->export_for_inlining()) if (this->export_for_inlining())
block = this->block_; block = this->block_;
Function::export_func_with_type(exp, name, this->type_, Function::export_func_with_type(exp, name, this->type_, this->results_,
this->is_method() && this->nointerface(), this->is_method() && this->nointerface(),
block, this->location_); block, this->location_);
} }
@ -5496,8 +5496,9 @@ Function::export_func(Export* exp, const std::string& name) const
void void
Function::export_func_with_type(Export* exp, const std::string& name, Function::export_func_with_type(Export* exp, const std::string& name,
const Function_type* fntype, bool nointerface, const Function_type* fntype,
Block* block, Location loc) Function::Results* result_vars,
bool nointerface, Block* block, Location loc)
{ {
exp->write_c_string("func "); exp->write_c_string("func ");
@ -5549,31 +5550,45 @@ Function::export_func_with_type(Export* exp, const std::string& name,
} }
exp->write_c_string(")"); exp->write_c_string(")");
const Typed_identifier_list* results = fntype->results(); const Typed_identifier_list* result_decls = fntype->results();
if (results != NULL) if (result_decls != NULL)
{ {
if (results->size() == 1 && results->begin()->name().empty()) if (result_decls->size() == 1
&& result_decls->begin()->name().empty()
&& block == NULL)
{ {
exp->write_c_string(" "); exp->write_c_string(" ");
exp->write_type(results->begin()->type()); exp->write_type(result_decls->begin()->type());
} }
else else
{ {
exp->write_c_string(" ("); exp->write_c_string(" (");
bool first = true; bool first = true;
for (Typed_identifier_list::const_iterator p = results->begin(); Results::const_iterator pr;
p != results->end(); if (result_vars != NULL)
++p) pr = result_vars->begin();
for (Typed_identifier_list::const_iterator pd = result_decls->begin();
pd != result_decls->end();
++pd)
{ {
if (first) if (first)
first = false; first = false;
else else
exp->write_c_string(", "); exp->write_c_string(", ");
exp->write_name(p->name()); // We only use pr->name, which may be artificial, if
exp->write_escape(p->note()); // need it for inlining.
if (block == NULL || result_vars == NULL)
exp->write_name(pd->name());
else
exp->write_name((*pr)->name());
exp->write_escape(pd->note());
exp->write_c_string(" "); exp->write_c_string(" ");
exp->write_type(p->type()); exp->write_type(pd->type());
if (result_vars != NULL)
++pr;
} }
if (result_vars != NULL)
go_assert(pr == result_vars->end());
exp->write_c_string(")"); exp->write_c_string(")");
} }
} }

6
gcc/go/gofrontend/gogo.h
View file

@ -1513,8 +1513,8 @@ class Function
// Export a function with a type. // Export a function with a type.
static void static void
export_func_with_type(Export*, const std::string& name, export_func_with_type(Export*, const std::string& name,
const Function_type*, bool nointerface, Block* block, const Function_type*, Results*, bool nointerface,
Location); Block* block, Location);
// Import a function. // Import a function.
static void static void
@ -1740,7 +1740,7 @@ class Function_declaration
void void
export_func(Export* exp, const std::string& name) const export_func(Export* exp, const std::string& name) const
{ {
Function::export_func_with_type(exp, name, this->fntype_, Function::export_func_with_type(exp, name, this->fntype_, NULL,
this->is_method() && this->nointerface(), this->is_method() && this->nointerface(),
NULL, this->location_); NULL, this->location_);
} }