-f68c03e509b26e7f483f2800eb70a5fbf3f74d0b
+f2cd046a4e0d681c3d21ee547b437d3eab8af268
The first line of this file holds the git revision number of the last
merge done from the gofrontend repository.
{
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;
}
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:
{
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;
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.
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;
}
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.
// 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_;
// 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_;
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
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));
}
}
}
+// 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
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.
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)
{
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);
statements.reserve(2);
Bstatement* switch_stmt = context->backend()->switch_statement(bfunction,
- bcall,
+ bindex,
cases,
clauses,
location);
return context->backend()->statement_list(statements);
}
+
// Dump the AST representation for select clauses.
void
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,
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();
+
+ Temporary_statement* scases = Statement::make_temporary(scases_type, NULL,
+ loc);
+ b->add_statement(scases);
- int64_t selstruct_size;
- if (!selstruct_type->backend_type_size(gogo, &selstruct_size))
- {
- go_assert(saw_errors());
- return Statement::make_error_statement(loc);
- }
+ 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);
- 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));
+ 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);
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.
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.
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*
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
Expression*
channel()
- { return this->channel_; }
+ { return this->channel_; }
Expression*
val()
// Lower statements.
void
- lower(Gogo*, Named_object*, Block*, Temporary_statement*);
+ lower(Gogo*, Named_object*, Block*, Temporary_statement*,
+ Temporary_statement*);
// Determine types.
void
// 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.
// Lower statements.
void
- lower(Gogo*, Named_object*, Block*, Temporary_statement*);
+ lower(Gogo*, Named_object*, Block*, Temporary_statement*, size_t,
+ Temporary_statement*);
// Determine types.
void
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*);
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_;
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.
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.
// 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.
// Dump the AST representation to a dump context.
void
dump_clause(Ast_dump_context*) const;
-
+
private:
// The list of case expressions.
Expression_list* cases_;
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.
make_chan_type_descriptor_type();
static Type*
- select_type(int ncases);
+ select_case_type();
protected:
int
// 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 {
// 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
}
}
// 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)
// 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
}
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]
}
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)
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
}
case caseSend:
- if raceenabled {
- racereadpc(unsafe.Pointer(c), cas.pc, chansendpc)
- }
if c.closed != 0 {
goto sclose
}
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)
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)
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 {
// 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)
}
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
checkPreempt()
}
- return casi
+ return casi, recvOK
sclose:
// send on closed channel
)
//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) {
projects / gcc.git / commitdiff