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

compiler, runtime: open code select

Browse source 
This is the gofrontend version of https://golang.org/cl/37933,
    https://golang.org/cl/37934, and https://golang.org/cl/37935.
    Open code the initialization of select cases.
    
    This is a step toward updating libgo to the 1.11 release.
    
    Reviewed-on: https://go-review.googlesource.com/135000

From-SVN: r264290
This commit is contained in:
Ian Lance Taylor 2018-09-13 21:32:24 +00:00
parent 283b9cafbd
commit 84cdf51de4
8 changed files with 278 additions and 365 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 @@
f68c03e509b26e7f483f2800eb70a5fbf3f74d0b
f2cd046a4e0d681c3d21ee547b437d3eab8af268
The first line of this file holds the git revision number of the last
merge done from the gofrontend repository.

25
gcc/go/gofrontend/escape.cc
View file

@ -1361,7 +1361,13 @@ Escape_analysis_assign::statement(Block*, size_t*, Statement* s)
{
Expression* init = s->temporary_statement()->init();
if (init != NULL)
this->assign(Node::make_node(s), Node::make_node(init));
{
Node* n = Node::make_node(init);
if (s->temporary_statement()->value_escapes())
this->assign(this->context_->sink(), n);
else
this->assign(Node::make_node(s), n);
}
}
break;
@ -1616,15 +1622,6 @@ Escape_analysis_assign::expression(Expression** pexpr)
}
break;
case Runtime::SELECTSEND:
{
// Send to a channel, lose track. The last argument is
// the address of the value to send.
Node* arg_node = Node::make_node(call->args()->back());
this->assign_deref(this->context_->sink(), arg_node);
}
break;
case Runtime::IFACEE2T2:
case Runtime::IFACEI2T2:
{
@ -2228,8 +2225,12 @@ Escape_analysis_assign::assign(Node* dst, Node* src)
case Expression::EXPRESSION_TEMPORARY_REFERENCE:
{
// Temporary is tracked through the underlying Temporary_statement.
Statement* t = dst->expr()->temporary_reference_expression()->statement();
dst = Node::make_node(t);
Temporary_statement* t =
dst->expr()->temporary_reference_expression()->statement();
if (t->value_escapes())
dst = this->context_->sink();
else
dst = Node::make_node(t);
}
break;

20
gcc/go/gofrontend/runtime.def
View file

@ -152,22 +152,10 @@ DEF_GO_RUNTIME(CHANRECV1, "runtime.chanrecv1", P2(CHAN, POINTER), R0())
DEF_GO_RUNTIME(CHANRECV2, "runtime.chanrecv2", P2(CHAN, POINTER), R1(BOOL))
// Start building a select statement.
DEF_GO_RUNTIME(NEWSELECT, "runtime.newselect", P3(POINTER, INT64, INT32), R0())
// Add a default clause to a select statement.
DEF_GO_RUNTIME(SELECTDEFAULT, "runtime.selectdefault", P1(POINTER), R0())
// Add a send clause to a select statement.
DEF_GO_RUNTIME(SELECTSEND, "runtime.selectsend", P3(POINTER, CHAN, POINTER),
R0())
// Add a receive clause to a select statement.
DEF_GO_RUNTIME(SELECTRECV, "runtime.selectrecv",
P4(POINTER, CHAN, POINTER, BOOLPTR), R0())
// Run a select, returning the index of the selected clause.
DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P1(POINTER), R1(INT))
// Run a select, returning the index of the selected clause and
// whether that channel received a value.
DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P3(POINTER, POINTER, INT),
R2(INT, BOOL))
// Panic.

232
gcc/go/gofrontend/statements.cc
View file

@ -4548,17 +4548,19 @@ Select_clauses::Select_clause::traverse(Traverse* traverse)
void
Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function,
Block* b, Temporary_statement* sel)
Block* b, Temporary_statement* scases,
size_t index, Temporary_statement* recvok)
{
Location loc = this->location_;
Expression* selref = Expression::make_temporary_reference(sel, loc);
selref = Expression::make_unary(OPERATOR_AND, selref, loc);
Expression* scase = Expression::make_temporary_reference(scases, loc);
Expression* index_expr = Expression::make_integer_ul(index, NULL, loc);
scase = Expression::make_array_index(scase, index_expr, NULL, NULL, loc);
if (this->is_default_)
{
go_assert(this->channel_ == NULL && this->val_ == NULL);
this->lower_default(b, selref);
this->lower_default(b, scase);
this->is_lowered_ = true;
return;
}
@ -4572,9 +4574,9 @@ Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function,
loc);
if (this->is_send_)
this->lower_send(b, selref, chanref);
this->lower_send(b, scase, chanref);
else
this->lower_recv(gogo, function, b, selref, chanref);
this->lower_recv(gogo, function, b, scase, chanref, recvok);
// Now all references should be handled through the statements, not
// through here.
@ -4585,18 +4587,16 @@ Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function,
// Lower a default clause in a select statement.
void
Select_clauses::Select_clause::lower_default(Block* b, Expression* selref)
Select_clauses::Select_clause::lower_default(Block* b, Expression* scase)
{
Location loc = this->location_;
Expression* call = Runtime::make_call(Runtime::SELECTDEFAULT, loc, 1,
selref);
b->add_statement(Statement::make_statement(call, true));
this->set_case(b, scase, Expression::make_nil(loc), NULL, caseDefault);
}
// Lower a send clause in a select statement.
void
Select_clauses::Select_clause::lower_send(Block* b, Expression* selref,
Select_clauses::Select_clause::lower_send(Block* b, Expression* scase,
Expression* chanref)
{
Location loc = this->location_;
@ -4611,22 +4611,29 @@ Select_clauses::Select_clause::lower_send(Block* b, Expression* selref,
// evaluate the send values in the required order.
Temporary_statement* val = Statement::make_temporary(valtype, this->val_,
loc);
// The value here escapes, because it might be sent on a channel.
// We record that via the Temporary_statement, so that the escape
// analysis pass can pick it up. The gc compiler lowers select
// statements after escape analysis, so it doesn't have to worry
// about this.
val->set_value_escapes();
b->add_statement(val);
Expression* valref = Expression::make_temporary_reference(val, loc);
Expression* valaddr = Expression::make_unary(OPERATOR_AND, valref, loc);
Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
valaddr = Expression::make_cast(unsafe_pointer_type, valaddr, loc);
Expression* call = Runtime::make_call(Runtime::SELECTSEND, loc, 3, selref,
chanref, valaddr);
b->add_statement(Statement::make_statement(call, true));
this->set_case(b, scase, chanref, valaddr, caseSend);
}
// Lower a receive clause in a select statement.
void
Select_clauses::Select_clause::lower_recv(Gogo* gogo, Named_object* function,
Block* b, Expression* selref,
Expression* chanref)
Block* b, Expression* scase,
Expression* chanref,
Temporary_statement* recvok)
{
Location loc = this->location_;
@ -4640,26 +4647,10 @@ Select_clauses::Select_clause::lower_recv(Gogo* gogo, Named_object* function,
Expression* valref = Expression::make_temporary_reference(val, loc);
Expression* valaddr = Expression::make_unary(OPERATOR_AND, valref, loc);
Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
valaddr = Expression::make_cast(unsafe_pointer_type, valaddr, loc);
Temporary_statement* closed_temp = NULL;
Expression* caddr;
if (this->closed_ == NULL && this->closedvar_ == NULL)
caddr = Expression::make_nil(loc);
else
{
closed_temp = Statement::make_temporary(Type::lookup_bool_type(), NULL,
loc);
b->add_statement(closed_temp);
Expression* cref = Expression::make_temporary_reference(closed_temp,
loc);
caddr = Expression::make_unary(OPERATOR_AND, cref, loc);
}
Expression* call = Runtime::make_call(Runtime::SELECTRECV, loc, 4, selref,
chanref, valaddr, caddr);
b->add_statement(Statement::make_statement(call, true));
this->set_case(b, scase, chanref, valaddr, caseRecv);
// If the block of statements is executed, arrange for the received
// value to move from VAL to the place where the statements expect
@ -4684,16 +4675,14 @@ Select_clauses::Select_clause::lower_recv(Gogo* gogo, Named_object* function,
if (this->closedvar_ != NULL)
{
go_assert(this->closed_ == NULL);
Expression* cref = Expression::make_temporary_reference(closed_temp,
loc);
Expression* cref = Expression::make_temporary_reference(recvok, loc);
this->closedvar_->var_value()->set_init(cref);
}
else if (this->closed_ != NULL && !this->closed_->is_sink_expression())
{
if (init == NULL)
init = new Block(b, loc);
Expression* cref = Expression::make_temporary_reference(closed_temp,
loc);
Expression* cref = Expression::make_temporary_reference(recvok, loc);
init->add_statement(Statement::make_assignment(this->closed_, cref,
loc));
}
@ -4709,6 +4698,45 @@ Select_clauses::Select_clause::lower_recv(Gogo* gogo, Named_object* function,
}
}
// Set the fields of an scase struct, an element in the array that we
// pass to the runtime function selectgo.
void
Select_clauses::Select_clause::set_case(Block* b,
Expression* scase,
Expression* chanref,
Expression* elem,
int kind)
{
Location loc = this->location_;
Struct_type* scase_type = scase->type()->struct_type();
int field_index = 0;
go_assert(scase_type->field(field_index)->is_field_name("c"));
Expression* ref = Expression::make_field_reference(scase, field_index, loc);
Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
chanref = Expression::make_unsafe_cast(unsafe_pointer_type, chanref, loc);
Statement* s = Statement::make_assignment(ref, chanref, loc);
b->add_statement(s);
if (elem != NULL)
{
field_index = 1;
go_assert(scase_type->field(field_index)->is_field_name("elem"));
ref = Expression::make_field_reference(scase->copy(), field_index, loc);
s = Statement::make_assignment(ref, elem, loc);
b->add_statement(s);
}
field_index = 2;
go_assert(scase_type->field(field_index)->is_field_name("kind"));
Type* uint16_type = Type::lookup_integer_type("uint16");
Expression* k = Expression::make_integer_ul(kind, uint16_type, loc);
ref = Expression::make_field_reference(scase->copy(), field_index, loc);
s = Statement::make_assignment(ref, k, loc);
b->add_statement(s);
}
// Determine types.
void
@ -4828,12 +4856,13 @@ Select_clauses::traverse(Traverse* traverse)
void
Select_clauses::lower(Gogo* gogo, Named_object* function, Block* b,
Temporary_statement* sel)
Temporary_statement* scases, Temporary_statement* recvok)
{
size_t i = 0;
for (Clauses::iterator p = this->clauses_.begin();
p != this->clauses_.end();
++p)
p->lower(gogo, function, b, sel);
++p, ++i)
p->lower(gogo, function, b, scases, i, recvok);
}
// Determine types.
@ -4872,13 +4901,13 @@ Select_clauses::may_fall_through() const
return false;
}
// Convert to the backend representation. We have already accumulated
// all the select information. Now we call selectgo, which will
// return the index of the clause to execute.
// Convert to the backend representation. Assemble the clauses and
// build a switch statement on the index value returned by the call to
// selectgo.
Bstatement*
Select_clauses::get_backend(Translate_context* context,
Temporary_statement* sel,
Temporary_statement* index,
Unnamed_label *break_label,
Location location)
{
@ -4909,21 +4938,14 @@ Select_clauses::get_backend(Translate_context* context,
clauses[i] = context->backend()->compound_statement(s, g);
}
Expression* selref = Expression::make_temporary_reference(sel, location);
selref = Expression::make_unary(OPERATOR_AND, selref, location);
Expression* call = Runtime::make_call(Runtime::SELECTGO, location, 1,
selref);
context->gogo()->lower_expression(context->function(), NULL, &call);
Bexpression* bcall = call->get_backend(context);
if (count == 0)
{
Bfunction* bfunction = context->function()->func_value()->get_decl();
return context->backend()->expression_statement(bfunction, bcall);
}
Expression* ref = Expression::make_temporary_reference(index, location);
Bexpression* bindex = ref->get_backend(context);
Bfunction* bfunction = context->function()->func_value()->get_decl();
if (count == 0)
return context->backend()->expression_statement(bfunction, bindex);
Expression* crash = Runtime::make_call(Runtime::UNREACHABLE, location, 0);
Bexpression* bcrash = crash->get_backend(context);
clauses[count] = context->backend()->expression_statement(bfunction, bcrash);
@ -4932,7 +4954,7 @@ Select_clauses::get_backend(Translate_context* context,
statements.reserve(2);
Bstatement* switch_stmt = context->backend()->switch_statement(bfunction,
bcall,
bindex,
cases,
clauses,
location);
@ -4943,6 +4965,7 @@ Select_clauses::get_backend(Translate_context* context,
return context->backend()->statement_list(statements);
}
// Dump the AST representation for select clauses.
void
@ -4967,10 +4990,10 @@ Select_statement::break_label()
return this->break_label_;
}
// Lower a select statement. This will still return a select
// statement, but it will be modified to implement the order of
// evaluation rules, and to include the send and receive statements as
// explicit statements in the clauses.
// Lower a select statement. This will return a block containing this
// select statement. The block will implement the order of evaluation
// rules, include the send and receive statements as explicit
// statements in the clauses, and call the runtime selectgo function.
Statement*
Select_statement::do_lower(Gogo* gogo, Named_object* function,
@ -4983,30 +5006,69 @@ Select_statement::do_lower(Gogo* gogo, Named_object* function,
Block* b = new Block(enclosing, loc);
go_assert(this->sel_ == NULL);
int ncases = this->clauses_->size();
Type* selstruct_type = Channel_type::select_type(ncases);
this->sel_ = Statement::make_temporary(selstruct_type, NULL, loc);
b->add_statement(this->sel_);
Type* scase_type = Channel_type::select_case_type();
Expression* ncases_expr =
Expression::make_integer_ul(ncases, NULL,
Linemap::predeclared_location());
Array_type* scases_type = Type::make_array_type(scase_type, ncases_expr);
scases_type->set_is_array_incomparable();
int64_t selstruct_size;
if (!selstruct_type->backend_type_size(gogo, &selstruct_size))
{
go_assert(saw_errors());
return Statement::make_error_statement(loc);
}
Temporary_statement* scases = Statement::make_temporary(scases_type, NULL,
loc);
b->add_statement(scases);
Expression* ref = Expression::make_temporary_reference(this->sel_, loc);
ref = Expression::make_unary(OPERATOR_AND, ref, loc);
Expression* selstruct_size_expr =
Expression::make_integer_int64(selstruct_size, NULL, loc);
Expression* size_expr = Expression::make_integer_ul(ncases, NULL, loc);
Expression* call = Runtime::make_call(Runtime::NEWSELECT, loc, 3,
ref, selstruct_size_expr, size_expr);
b->add_statement(Statement::make_statement(call, true));
Expression* ncases2_expr =
Expression::make_integer_ul(ncases * 2, NULL,
Linemap::predeclared_location());
Type* uint16_type = Type::lookup_integer_type("uint16");
Array_type* order_type = Type::make_array_type(uint16_type, ncases2_expr);
order_type->set_is_array_incomparable();
Temporary_statement* order = Statement::make_temporary(order_type, NULL,
loc);
b->add_statement(order);
Type* int_type = Type::lookup_integer_type("int");
this->index_ = Statement::make_temporary(int_type, NULL, loc);
b->add_statement(this->index_);
Type* bool_type = Type::lookup_bool_type();
Temporary_statement* recvok = Statement::make_temporary(bool_type, NULL,
loc);
b->add_statement(recvok);
// Initialize the scases array.
this->clauses_->lower(gogo, function, b, scases, recvok);
// Build the call to selectgo. Later, in do_get_backend, we will
// build a switch on the result that branches to the various cases.
Expression* scases_ref = Expression::make_temporary_reference(scases, loc);
scases_ref = Expression::make_unary(OPERATOR_AND, scases_ref, loc);
Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
scases_ref = Expression::make_cast(unsafe_pointer_type, scases_ref, loc);
Expression* order_ref = Expression::make_temporary_reference(order, loc);
order_ref = Expression::make_unary(OPERATOR_AND, order_ref, loc);
order_ref = Expression::make_cast(unsafe_pointer_type, order_ref, loc);
Expression* count_expr = Expression::make_integer_ul(ncases, int_type, loc);
Call_expression* call = Runtime::make_call(Runtime::SELECTGO, loc, 3,
scases_ref, order_ref,
count_expr);
Expression* result = Expression::make_call_result(call, 0);
Expression* ref = Expression::make_temporary_reference(this->index_, loc);
Statement* s = Statement::make_assignment(ref, result, loc);
b->add_statement(s);
result = Expression::make_call_result(call, 1);
ref = Expression::make_temporary_reference(recvok, loc);
s = Statement::make_assignment(ref, result, loc);
b->add_statement(s);
this->clauses_->lower(gogo, function, b, this->sel_);
this->is_lowered_ = true;
b->add_statement(this);
@ -5031,8 +5093,8 @@ Select_statement::do_may_fall_through() const
Bstatement*
Select_statement::do_get_backend(Translate_context* context)
{
return this->clauses_->get_backend(context, this->sel_, this->break_label(),
this->location());
return this->clauses_->get_backend(context, this->index_,
this->break_label(), this->location());
}
// Dump the AST representation for a select statement.

50
gcc/go/gofrontend/statements.h
View file

@ -622,7 +622,8 @@ class Temporary_statement : public Statement
public:
Temporary_statement(Type* type, Expression* init, Location location)
: Statement(STATEMENT_TEMPORARY, location),
type_(type), init_(init), bvariable_(NULL), is_address_taken_(false)
type_(type), init_(init), bvariable_(NULL), is_address_taken_(false),
value_escapes_(false)
{ }
// Return the type of the temporary variable.
@ -640,6 +641,16 @@ class Temporary_statement : public Statement
set_is_address_taken()
{ this->is_address_taken_ = true; }
// Whether the value escapes.
bool
value_escapes() const
{ return this->value_escapes_; }
// Record that the value escapes.
void
set_value_escapes()
{ this->value_escapes_ = true; }
// Return the temporary variable. This should not be called until
// after the statement itself has been converted.
Bvariable*
@ -676,6 +687,9 @@ class Temporary_statement : public Statement
Bvariable* bvariable_;
// True if something takes the address of this temporary variable.
bool is_address_taken_;
// True if the value assigned to this temporary variable escapes.
// This is used for select statements.
bool value_escapes_;
};
// A variable declaration. This marks the point in the code where a
@ -851,7 +865,7 @@ class Send_statement : public Statement
Expression*
channel()
{ return this->channel_; }
{ return this->channel_; }
Expression*
val()
@ -924,7 +938,8 @@ class Select_clauses
// Lower statements.
void
lower(Gogo*, Named_object*, Block*, Temporary_statement*);
lower(Gogo*, Named_object*, Block*, Temporary_statement*,
Temporary_statement*);
// Determine types.
void
@ -941,7 +956,7 @@ class Select_clauses
// Convert to the backend representation.
Bstatement*
get_backend(Translate_context*, Temporary_statement* sel,
get_backend(Translate_context*, Temporary_statement* index,
Unnamed_label* break_label, Location);
// Dump AST representation.
@ -974,7 +989,8 @@ class Select_clauses
// Lower statements.
void
lower(Gogo*, Named_object*, Block*, Temporary_statement*);
lower(Gogo*, Named_object*, Block*, Temporary_statement*, size_t,
Temporary_statement*);
// Determine types.
void
@ -1027,6 +1043,14 @@ class Select_clauses
dump_clause(Ast_dump_context*) const;
private:
// These values must match the values in libgo/go/runtime/select.go.
enum
{
caseRecv = 1,
caseSend = 2,
caseDefault = 3,
};
void
lower_default(Block*, Expression*);
@ -1034,7 +1058,11 @@ class Select_clauses
lower_send(Block*, Expression*, Expression*);
void
lower_recv(Gogo*, Named_object*, Block*, Expression*, Expression*);
lower_recv(Gogo*, Named_object*, Block*, Expression*, Expression*,
Temporary_statement*);
void
set_case(Block*, Expression*, Expression*, Expression*, int);
// The channel.
Expression* channel_;
@ -1072,7 +1100,7 @@ class Select_statement : public Statement
public:
Select_statement(Location location)
: Statement(STATEMENT_SELECT, location),
clauses_(NULL), sel_(NULL), break_label_(NULL), is_lowered_(false)
clauses_(NULL), index_(NULL), break_label_(NULL), is_lowered_(false)
{ }
// Add the clauses.
@ -1115,8 +1143,8 @@ class Select_statement : public Statement
private:
// The select clauses.
Select_clauses* clauses_;
// A temporary which holds the select structure we build up at runtime.
Temporary_statement* sel_;
// A temporary that holds the index value returned by selectgo.
Temporary_statement* index_;
// The break label.
Unnamed_label* break_label_;
// Whether this statement has been lowered.
@ -1609,7 +1637,7 @@ class Case_clauses
// Dump the AST representation to a dump context.
void
dump_clauses(Ast_dump_context*) const;
private:
// For a constant switch we need to keep a record of constants we
// have already seen.
@ -1683,7 +1711,7 @@ class Case_clauses
// Dump the AST representation to a dump context.
void
dump_clause(Ast_dump_context*) const;
private:
// The list of case expressions.
Expression_list* cases_;

46
gcc/go/gofrontend/types.cc
View file

@ -8557,51 +8557,29 @@ Channel_type::do_import(Import* imp)
return Type::make_channel_type(may_send, may_receive, element_type);
}
// Return the type to manage a select statement with ncases case
// statements. A value of this type is allocated on the stack. This
// must match the type hselect in libgo/go/runtime/select.go.
// Return the type that the runtime package uses for one case of a
// select statement. An array of values of this type is allocated on
// the stack. This must match scase in libgo/go/runtime/select.go.
Type*
Channel_type::select_type(int ncases)
Channel_type::select_case_type()
{
Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
Type* uint16_type = Type::lookup_integer_type("uint16");
static Struct_type* scase_type;
if (scase_type == NULL)
{
Type* uintptr_type = Type::lookup_integer_type("uintptr");
Type* uint64_type = Type::lookup_integer_type("uint64");
Type* unsafe_pointer_type =
Type::make_pointer_type(Type::make_void_type());
Type* uint16_type = Type::lookup_integer_type("uint16");
Type* int64_type = Type::lookup_integer_type("int64");
scase_type =
Type::make_builtin_struct_type(7,
Type::make_builtin_struct_type(4,
"c", unsafe_pointer_type,
"elem", unsafe_pointer_type,
"chan", unsafe_pointer_type,
"pc", uintptr_type,
"kind", uint16_type,
"index", uint16_type,
"receivedp", unsafe_pointer_type,
"releasetime", uint64_type);
"releasetime", int64_type);
scase_type->set_is_struct_incomparable();
}
Expression* ncases_expr =
Expression::make_integer_ul(ncases, NULL, Linemap::predeclared_location());
Array_type* scases = Type::make_array_type(scase_type, ncases_expr);
scases->set_is_array_incomparable();
Array_type* order = Type::make_array_type(uint16_type, ncases_expr);
order->set_is_array_incomparable();
Struct_type* ret =
Type::make_builtin_struct_type(7,
"tcase", uint16_type,
"ncase", uint16_type,
"pollorder", unsafe_pointer_type,
"lockorder", unsafe_pointer_type,
"scase", scases,
"lockorderarr", order,
"pollorderarr", order);
ret->set_is_struct_incomparable();
return ret;
return scase_type;
}
// Make a new channel type.

2
gcc/go/gofrontend/types.h
View file

@ -2981,7 +2981,7 @@ class Channel_type : public Type
make_chan_type_descriptor_type();
static Type*
select_type(int ncases);
select_case_type();
protected:
int

266
libgo/go/runtime/select.go
View file

@ -7,146 +7,36 @@ package runtime
// This file contains the implementation of Go select statements.
import (
"runtime/internal/sys"
"unsafe"
)
// For gccgo, use go:linkname to rename compiler-called functions to
// themselves, so that the compiler will export them.
//
//go:linkname newselect runtime.newselect
//go:linkname selectdefault runtime.selectdefault
//go:linkname selectsend runtime.selectsend
//go:linkname selectrecv runtime.selectrecv
//go:linkname selectgo runtime.selectgo
const debugSelect = false
// scase.kind values.
// Known to compiler.
// Changes here must also be made in src/cmd/compile/internal/gc/select.go's walkselect.
const (
// scase.kind
caseNil = iota
caseRecv
caseSend
caseDefault
)
// Select statement header.
// Known to compiler.
// Changes here must also be made in src/cmd/internal/gc/select.go's selecttype.
type hselect struct {
tcase uint16 // total count of scase[]
ncase uint16 // currently filled scase[]
pollorder *uint16 // case poll order
lockorder *uint16 // channel lock order
scase [1]scase // one per case (in order of appearance)
}
// Select case descriptor.
// Known to compiler.
// Changes here must also be made in src/cmd/internal/gc/select.go's selecttype.
// Changes here must also be made in src/cmd/internal/gc/select.go's scasetype.
type scase struct {
elem unsafe.Pointer // data element
c *hchan // chan
pc uintptr // return pc (for race detector / msan)
elem unsafe.Pointer // data element
kind uint16
receivedp *bool // pointer to received bool, if any
releasetime int64
}
var (
chansendpc = funcPC(chansend)
chanrecvpc = funcPC(chanrecv)
)
func selectsize(size uintptr) uintptr {
selsize := unsafe.Sizeof(hselect{}) +
(size-1)*unsafe.Sizeof(hselect{}.scase[0]) +
size*unsafe.Sizeof(*hselect{}.lockorder) +
size*unsafe.Sizeof(*hselect{}.pollorder)
return round(selsize, sys.Int64Align)
}
func newselect(sel *hselect, selsize int64, size int32) {
if selsize != int64(selectsize(uintptr(size))) {
print("runtime: bad select size ", selsize, ", want ", selectsize(uintptr(size)), "\n")
throw("bad select size")
}
if size != int32(uint16(size)) {
throw("select size too large")
}
sel.tcase = uint16(size)
sel.ncase = 0
sel.lockorder = (*uint16)(add(unsafe.Pointer(&sel.scase), uintptr(size)*unsafe.Sizeof(hselect{}.scase[0])))
sel.pollorder = (*uint16)(add(unsafe.Pointer(sel.lockorder), uintptr(size)*unsafe.Sizeof(*hselect{}.lockorder)))
// For gccgo the temporary variable will not have been zeroed.
memclrNoHeapPointers(unsafe.Pointer(&sel.scase), uintptr(size)*unsafe.Sizeof(hselect{}.scase[0])+uintptr(size)*unsafe.Sizeof(*hselect{}.lockorder)+uintptr(size)*unsafe.Sizeof(*hselect{}.pollorder))
if debugSelect {
print("newselect s=", sel, " size=", size, "\n")
}
}
func selectsend(sel *hselect, c *hchan, elem unsafe.Pointer) {
pc := getcallerpc()
i := sel.ncase
if i >= sel.tcase {
throw("selectsend: too many cases")
}
sel.ncase = i + 1
if c == nil {
return
}
cas := (*scase)(add(unsafe.Pointer(&sel.scase), uintptr(i)*unsafe.Sizeof(sel.scase[0])))
cas.pc = pc
cas.c = c
cas.kind = caseSend
cas.elem = elem
if debugSelect {
print("selectsend s=", sel, " pc=", hex(cas.pc), " chan=", cas.c, "\n")
}
}
func selectrecv(sel *hselect, c *hchan, elem unsafe.Pointer, received *bool) {
pc := getcallerpc()
i := sel.ncase
if i >= sel.tcase {
throw("selectrecv: too many cases")
}
sel.ncase = i + 1
if c == nil {
return
}
cas := (*scase)(add(unsafe.Pointer(&sel.scase), uintptr(i)*unsafe.Sizeof(sel.scase[0])))
cas.pc = pc
cas.c = c
cas.kind = caseRecv
cas.elem = elem
cas.receivedp = received
if debugSelect {
print("selectrecv s=", sel, " pc=", hex(cas.pc), " chan=", cas.c, "\n")
}
}
func selectdefault(sel *hselect) {
pc := getcallerpc()
i := sel.ncase
if i >= sel.tcase {
throw("selectdefault: too many cases")
}
sel.ncase = i + 1
cas := (*scase)(add(unsafe.Pointer(&sel.scase), uintptr(i)*unsafe.Sizeof(sel.scase[0])))
cas.pc = pc
cas.c = nil
cas.kind = caseDefault
if debugSelect {
print("selectdefault s=", sel, " pc=", hex(cas.pc), "\n")
}
}
func sellock(scases []scase, lockorder []uint16) {
var c *hchan
for _, o := range lockorder {
@ -209,26 +99,39 @@ func block() {
// selectgo implements the select statement.
//
// *sel is on the current goroutine's stack (regardless of any
// escaping in selectgo).
// cas0 points to an array of type [ncases]scase, and order0 points to
// an array of type [2*ncases]uint16. Both reside on the goroutine's
// stack (regardless of any escaping in selectgo).
//
// selectgo returns the index of the chosen scase, which matches the
// ordinal position of its respective select{recv,send,default} call.
func selectgo(sel *hselect) int {
// Also, if the chosen scase was a receive operation, it returns whether
// a value was received.
func selectgo(cas0 *scase, order0 *uint16, ncases int) (int, bool) {
if debugSelect {
print("select: sel=", sel, "\n")
}
if sel.ncase != sel.tcase {
throw("selectgo: case count mismatch")
print("select: cas0=", cas0, "\n")
}
scaseslice := slice{unsafe.Pointer(&sel.scase), int(sel.ncase), int(sel.ncase)}
scases := *(*[]scase)(unsafe.Pointer(&scaseslice))
cas1 := (*[1 << 16]scase)(unsafe.Pointer(cas0))
order1 := (*[1 << 17]uint16)(unsafe.Pointer(order0))
scases := cas1[:ncases:ncases]
pollorder := order1[:ncases:ncases]
lockorder := order1[ncases:][:ncases:ncases]
// Replace send/receive cases involving nil channels with
// caseNil so logic below can assume non-nil channel.
for i := range scases {
cas := &scases[i]
if cas.c == nil && cas.kind != caseDefault {
*cas = scase{}
}
}
var t0 int64
if blockprofilerate > 0 {
t0 = cputicks()
for i := 0; i < int(sel.ncase); i++ {
for i := 0; i < ncases; i++ {
scases[i].releasetime = -1
}
}
@ -241,10 +144,13 @@ func selectgo(sel *hselect) int {
// cases correctly, and they are rare enough not to bother
// optimizing (and needing to test).
// needed for gccgo, which doesn't zero pollorder
if ncases > 0 {
pollorder[0] = 0
}
// generate permuted order
pollslice := slice{unsafe.Pointer(sel.pollorder), int(sel.ncase), int(sel.ncase)}
pollorder := *(*[]uint16)(unsafe.Pointer(&pollslice))
for i := 1; i < int(sel.ncase); i++ {
for i := 1; i < ncases; i++ {
j := fastrandn(uint32(i + 1))
pollorder[i] = pollorder[j]
pollorder[j] = uint16(i)
@ -252,9 +158,7 @@ func selectgo(sel *hselect) int {
// sort the cases by Hchan address to get the locking order.
// simple heap sort, to guarantee n log n time and constant stack footprint.
lockslice := slice{unsafe.Pointer(sel.lockorder), int(sel.ncase), int(sel.ncase)}
lockorder := *(*[]uint16)(unsafe.Pointer(&lockslice))
for i := 0; i < int(sel.ncase); i++ {
for i := 0; i < ncases; i++ {
j := i
// Start with the pollorder to permute cases on the same channel.
c := scases[pollorder[i]].c
@ -265,7 +169,7 @@ func selectgo(sel *hselect) int {
}
lockorder[j] = pollorder[i]
}
for i := int(sel.ncase) - 1; i >= 0; i-- {
for i := ncases - 1; i >= 0; i-- {
o := lockorder[i]
c := scases[o].c
lockorder[i] = lockorder[0]
@ -287,14 +191,15 @@ func selectgo(sel *hselect) int {
}
lockorder[j] = o
}
/*
for i := 0; i+1 < int(sel.ncase); i++ {
if debugSelect {
for i := 0; i+1 < ncases; i++ {
if scases[lockorder[i]].c.sortkey() > scases[lockorder[i+1]].c.sortkey() {
print("i=", i, " x=", lockorder[i], " y=", lockorder[i+1], "\n")
throw("select: broken sort")
}
}
*/
}
// lock all the channels involved in the select
sellock(scases, lockorder)
@ -316,7 +221,8 @@ loop:
var dfl *scase
var casi int
var cas *scase
for i := 0; i < int(sel.ncase); i++ {
var recvOK bool
for i := 0; i < ncases; i++ {
casi = int(pollorder[i])
cas = &scases[casi]
c = cas.c
@ -338,9 +244,6 @@ loop:
}
case caseSend:
if raceenabled {
racereadpc(unsafe.Pointer(c), cas.pc, chansendpc)
}
if c.closed != 0 {
goto sclose
}
@ -469,26 +372,11 @@ loop:
c = cas.c
if debugSelect {
print("wait-return: sel=", sel, " c=", c, " cas=", cas, " kind=", cas.kind, "\n")
print("wait-return: cas0=", cas0, " c=", c, " cas=", cas, " kind=", cas.kind, "\n")
}
if cas.kind == caseRecv && cas.receivedp != nil {
*cas.receivedp = true
}
if raceenabled {
if cas.kind == caseRecv && cas.elem != nil {
raceWriteObjectPC(c.elemtype, cas.elem, cas.pc, chanrecvpc)
} else if cas.kind == caseSend {
raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
}
}
if msanenabled {
if cas.kind == caseRecv && cas.elem != nil {
msanwrite(cas.elem, c.elemtype.size)
} else if cas.kind == caseSend {
msanread(cas.elem, c.elemtype.size)
}
if cas.kind == caseRecv {
recvOK = true
}
selunlock(scases, lockorder)
@ -496,19 +384,7 @@ loop:
bufrecv:
// can receive from buffer
if raceenabled {
if cas.elem != nil {
raceWriteObjectPC(c.elemtype, cas.elem, cas.pc, chanrecvpc)
}
raceacquire(chanbuf(c, c.recvx))
racerelease(chanbuf(c, c.recvx))
}
if msanenabled && cas.elem != nil {
msanwrite(cas.elem, c.elemtype.size)
}
if cas.receivedp != nil {
*cas.receivedp = true
}
recvOK = true
qp = chanbuf(c, c.recvx)
if cas.elem != nil {
typedmemmove(c.elemtype, cas.elem, qp)
@ -524,14 +400,6 @@ bufrecv:
bufsend:
// can send to buffer
if raceenabled {
raceacquire(chanbuf(c, c.sendx))
racerelease(chanbuf(c, c.sendx))
raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
}
if msanenabled {
msanread(cas.elem, c.elemtype.size)
}
typedmemmove(c.elemtype, chanbuf(c, c.sendx), cas.elem)
c.sendx++
if c.sendx == c.dataqsiz {
@ -545,19 +413,15 @@ recv:
// can receive from sleeping sender (sg)
recv(c, sg, cas.elem, func() { selunlock(scases, lockorder) }, 2)
if debugSelect {
print("syncrecv: sel=", sel, " c=", c, "\n")
}
if cas.receivedp != nil {
*cas.receivedp = true
print("syncrecv: cas0=", cas0, " c=", c, "\n")
}
recvOK = true
goto retc
rclose:
// read at end of closed channel
selunlock(scases, lockorder)
if cas.receivedp != nil {
*cas.receivedp = false
}
recvOK = false
if cas.elem != nil {
typedmemclr(c.elemtype, cas.elem)
}
@ -568,15 +432,9 @@ rclose:
send:
// can send to a sleeping receiver (sg)
if raceenabled {
raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
}
if msanenabled {
msanread(cas.elem, c.elemtype.size)
}
send(c, sg, cas.elem, func() { selunlock(scases, lockorder) }, 2)
if debugSelect {
print("syncsend: sel=", sel, " c=", c, "\n")
print("syncsend: cas0=", cas0, " c=", c, "\n")
}
goto retc
@ -591,7 +449,7 @@ retc:
checkPreempt()
}
return casi
return casi, recvOK
sclose:
// send on closed channel
@ -625,27 +483,25 @@ const (
)
//go:linkname reflect_rselect reflect.rselect
func reflect_rselect(cases []runtimeSelect) (chosen int, recvOK bool) {
// flagNoScan is safe here, because all objects are also referenced from cases.
size := selectsize(uintptr(len(cases)))
sel := (*hselect)(mallocgc(size, nil, true))
newselect(sel, int64(size), int32(len(cases)))
r := new(bool)
func reflect_rselect(cases []runtimeSelect) (int, bool) {
if len(cases) == 0 {
block()
}
sel := make([]scase, len(cases))
order := make([]uint16, 2*len(cases))
for i := range cases {
rc := &cases[i]
switch rc.dir {
case selectDefault:
selectdefault(sel)
sel[i] = scase{kind: caseDefault}
case selectSend:
selectsend(sel, rc.ch, rc.val)
sel[i] = scase{kind: caseSend, c: rc.ch, elem: rc.val}
case selectRecv:
selectrecv(sel, rc.ch, rc.val, r)
sel[i] = scase{kind: caseRecv, c: rc.ch, elem: rc.val}
}
}
chosen = selectgo(sel)
recvOK = *r
return
return selectgo(&sel[0], &order[0], len(cases))
}
func (q *waitq) dequeueSudoG(sgp *sudog) {