return new Func_expression(function, closure, location);
}
-// A function descriptor. A function descriptor is a struct with a
-// single field pointing to the function code. This is used for
-// functions without closures.
+// Class Func_descriptor_expression.
-class Func_descriptor_expression : public Expression
-{
- public:
- Func_descriptor_expression(Named_object* fn, Named_object* dfn)
- : Expression(EXPRESSION_FUNC_DESCRIPTOR, fn->location()),
- fn_(fn), dfn_(dfn), dvar_(NULL)
- {
- go_assert(!fn->is_function() || !fn->func_value()->needs_closure());
- }
-
- // Make the function descriptor type, so that it can be converted.
- static void
- make_func_descriptor_type();
-
- protected:
- int
- do_traverse(Traverse*)
- { return TRAVERSE_CONTINUE; }
-
- Type*
- do_type();
-
- void
- do_determine_type(const Type_context*)
- { }
-
- Expression*
- do_copy()
- { return Expression::make_func_descriptor(this->fn_, this->dfn_); }
-
- bool
- do_is_addressable() const
- { return true; }
+// Constructor.
- tree
- do_get_tree(Translate_context*);
+Func_descriptor_expression::Func_descriptor_expression(Named_object* fn)
+ : Expression(EXPRESSION_FUNC_DESCRIPTOR, fn->location()),
+ fn_(fn), dfn_(NULL), dvar_(NULL)
+{
+ go_assert(!fn->is_function() || !fn->func_value()->needs_closure());
+}
- void
- do_dump_expression(Ast_dump_context* context) const
- { context->ostream() << "[descriptor " << this->fn_->name() << "]"; }
+// Traversal.
- private:
- // The type of all function descriptors.
- static Type* descriptor_type;
-
- // The function for which this is the descriptor.
- Named_object* fn_;
- // The descriptor function.
- Named_object* dfn_;
- // The descriptor variable.
- Bvariable* dvar_;
-};
+int
+Func_descriptor_expression::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
// All function descriptors have the same type.
return Func_descriptor_expression::descriptor_type;
}
+// Copy a Func_descriptor_expression;
+
+Expression*
+Func_descriptor_expression::do_copy()
+{
+ Func_descriptor_expression* fde =
+ Expression::make_func_descriptor(this->fn_);
+ if (this->dfn_ != NULL)
+ fde->set_descriptor_wrapper(this->dfn_);
+ return fde;
+}
+
// The tree for a function descriptor.
tree
return var_to_tree(bvar);
}
+// Print a function descriptor expression.
+
+void
+Func_descriptor_expression::do_dump_expression(Ast_dump_context* context) const
+{
+ context->ostream() << "[descriptor " << this->fn_->name() << "]";
+}
+
// Make a function descriptor expression.
-Expression*
-Expression::make_func_descriptor(Named_object* fn, Named_object* dfn)
+Func_descriptor_expression*
+Expression::make_func_descriptor(Named_object* fn)
{
- return new Func_descriptor_expression(fn, dfn);
+ return new Func_descriptor_expression(fn);
}
// Make the function descriptor type, so that it can be converted.
class Binary_expression;
class Call_expression;
class Func_expression;
+class Func_descriptor_expression;
class Unknown_expression;
class Index_expression;
class Map_index_expression;
// Make a function descriptor, an immutable struct with a single
// field that points to the function code. This may only be used
// with functions that do not have closures. FN is the function for
- // which we are making the descriptor. DFN is the descriptor
- // function wrapper.
- static Expression*
- make_func_descriptor(Named_object* fn, Named_object* dfn);
+ // which we are making the descriptor.
+ static Func_descriptor_expression*
+ make_func_descriptor(Named_object* fn);
// Make a reference to the code of a function. This is used to set
// descriptor and closure fields.
Expression* closure_;
};
+// A function descriptor. A function descriptor is a struct with a
+// single field pointing to the function code. This is used for
+// functions without closures.
+
+class Func_descriptor_expression : public Expression
+{
+ public:
+ Func_descriptor_expression(Named_object* fn);
+
+ // Set the descriptor wrapper.
+ void
+ set_descriptor_wrapper(Named_object* dfn)
+ {
+ go_assert(this->dfn_ == NULL);
+ this->dfn_ = dfn;
+ }
+
+ // Make the function descriptor type, so that it can be converted.
+ static void
+ make_func_descriptor_type();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy();
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_dump_expression(Ast_dump_context* context) const;
+
+ private:
+ // The type of all function descriptors.
+ static Type* descriptor_type;
+
+ // The function for which this is the descriptor.
+ Named_object* fn_;
+ // The descriptor function.
+ Named_object* dfn_;
+ // The descriptor variable.
+ Bvariable* dvar_;
+};
+
// A reference to an unknown name.
class Unknown_expression : public Parser_expression
{
no->func_value()->set_closure_type();
- // Make sure that every externally visible function has a
- // descriptor, so that packages that import this one can refer to
- // it.
- if (!Gogo::is_hidden_name(no->name())
- && !no->func_value()->is_method()
- && !no->func_value()->is_descriptor_wrapper())
- no->func_value()->descriptor(this->gogo_, no);
-
go_assert(this->function_ == NULL);
this->function_ = no;
int t = no->func_value()->traverse(this);
void
Gogo::lower_parse_tree()
{
- // Create a function descriptor for any function that is declared in
- // this package. This is so that we have a descriptor for functions
- // written in assembly. Gather the descriptors first so that we
- // don't add declarations while looping over them.
- std::vector<Named_object*> fndecls;
- Bindings* b = this->package_->bindings();
- for (Bindings::const_declarations_iterator p = b->begin_declarations();
- p != b->end_declarations();
- ++p)
- {
- Named_object* no = p->second;
- if (no->is_function_declaration()
- && !no->func_declaration_value()->type()->is_method()
- && !Linemap::is_predeclared_location(no->location()))
- fndecls.push_back(no);
- }
- for (std::vector<Named_object*>::const_iterator p = fndecls.begin();
- p != fndecls.end();
- ++p)
- (*p)->func_declaration_value()->descriptor(this, *p);
- fndecls.clear();
-
Lower_parse_tree lower_parse_tree(this, NULL);
this->traverse(&lower_parse_tree);
}
lower.constant(no, false);
}
+// Traverse the tree to create function descriptors as needed.
+
+class Create_function_descriptors : public Traverse
+{
+ public:
+ Create_function_descriptors(Gogo* gogo)
+ : Traverse(traverse_functions | traverse_expressions),
+ gogo_(gogo)
+ { }
+
+ int
+ function(Named_object*);
+
+ int
+ expression(Expression**);
+
+ private:
+ Gogo* gogo_;
+};
+
+// Create a descriptor for every top-level exported function.
+
+int
+Create_function_descriptors::function(Named_object* no)
+{
+ if (no->is_function()
+ && no->func_value()->enclosing() == NULL
+ && !no->func_value()->is_method()
+ && !no->func_value()->is_descriptor_wrapper()
+ && !Gogo::is_hidden_name(no->name()))
+ no->func_value()->descriptor(this->gogo_, no);
+
+ return TRAVERSE_CONTINUE;
+}
+
+// If we see a function referenced in any way other than calling it,
+// create a descriptor for it.
+
+int
+Create_function_descriptors::expression(Expression** pexpr)
+{
+ Expression* expr = *pexpr;
+
+ Func_expression* fe = expr->func_expression();
+ if (fe != NULL)
+ {
+ // We would not get here for a call to this function, so this is
+ // a reference to a function other than calling it. We need a
+ // descriptor.
+ if (fe->closure() != NULL)
+ return TRAVERSE_CONTINUE;
+ Named_object* no = fe->named_object();
+ if (no->is_function() && !no->func_value()->is_method())
+ no->func_value()->descriptor(this->gogo_, no);
+ else if (no->is_function_declaration()
+ && !no->func_declaration_value()->type()->is_method()
+ && !Linemap::is_predeclared_location(no->location()))
+ no->func_declaration_value()->descriptor(this->gogo_, no);
+ return TRAVERSE_CONTINUE;
+ }
+
+ Call_expression* ce = expr->call_expression();
+ if (ce != NULL)
+ {
+ Expression* fn = ce->fn();
+ if (fn->func_expression() != NULL)
+ {
+ // Traverse the arguments but not the function.
+ Expression_list* args = ce->args();
+ if (args != NULL)
+ {
+ if (args->traverse(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Create function descriptors as needed. We need a function
+// descriptor for all exported functions and for all functions that
+// are referenced without being called.
+
+void
+Gogo::create_function_descriptors()
+{
+ // Create a function descriptor for any exported function that is
+ // declared in this package. This is so that we have a descriptor
+ // for functions written in assembly. Gather the descriptors first
+ // so that we don't add declarations while looping over them.
+ std::vector<Named_object*> fndecls;
+ Bindings* b = this->package_->bindings();
+ for (Bindings::const_declarations_iterator p = b->begin_declarations();
+ p != b->end_declarations();
+ ++p)
+ {
+ Named_object* no = p->second;
+ if (no->is_function_declaration()
+ && !no->func_declaration_value()->type()->is_method()
+ && !Linemap::is_predeclared_location(no->location())
+ && !Gogo::is_hidden_name(no->name()))
+ fndecls.push_back(no);
+ }
+ for (std::vector<Named_object*>::const_iterator p = fndecls.begin();
+ p != fndecls.end();
+ ++p)
+ (*p)->func_declaration_value()->descriptor(this, *p);
+ fndecls.clear();
+
+ Create_function_descriptors cfd(this);
+ this->traverse(&cfd);
+}
+
// Look for interface types to finalize methods of inherited
// interfaces.
}
gogo->add_statement(s);
- gogo->add_block(gogo->finish_block(loc), loc);
+ Block* b = gogo->finish_block(loc);
+ gogo->add_block(b, loc);
+ gogo->lower_block(dno, b);
gogo->finish_function(loc);
return dno;
go_assert(!this->is_descriptor_wrapper_);
if (this->descriptor_ == NULL)
{
- Named_object* dno;
- if (no->package() != NULL
- || Linemap::is_predeclared_location(no->location()))
- dno = NULL;
- else
- dno = Function::make_descriptor_wrapper(gogo, no, this->type_);
- this->descriptor_ = Expression::make_func_descriptor(no, dno);
+ // Make and record the descriptor first, so that when we lower
+ // the descriptor wrapper we don't try to make it again.
+ Func_descriptor_expression* descriptor =
+ Expression::make_func_descriptor(no);
+ this->descriptor_ = descriptor;
+ if (no->package() == NULL
+ && !Linemap::is_predeclared_location(no->location()))
+ {
+ Named_object* dno = Function::make_descriptor_wrapper(gogo, no,
+ this->type_);
+ descriptor->set_descriptor_wrapper(dno);
+ }
}
return this->descriptor_;
}
go_assert(!this->fntype_->is_method());
if (this->descriptor_ == NULL)
{
- Named_object* dno;
- if (no->package() != NULL
- || Linemap::is_predeclared_location(no->location()))
- dno = NULL;
- else
- dno = Function::make_descriptor_wrapper(gogo, no, this->fntype_);
- this->descriptor_ = Expression::make_func_descriptor(no, dno);
+ // Make and record the descriptor first, so that when we lower
+ // the descriptor wrapper we don't try to make it again.
+ Func_descriptor_expression* descriptor =
+ Expression::make_func_descriptor(no);
+ this->descriptor_ = descriptor;
+ if (no->package() == NULL
+ && !Linemap::is_predeclared_location(no->location()))
+ {
+ Named_object* dno = Function::make_descriptor_wrapper(gogo, no,
+ this->fntype_);
+ descriptor->set_descriptor_wrapper(dno);
+ }
}
return this->descriptor_;
}
projects / gcc.git / commitdiff