"func @\"\".chanrecv2 (@\"\".chanType·2 *byte, @\"\".hchan·3 <-chan any, @\"\".elem·4 *any) (? bool)\n"
"func @\"\".chansend1 (@\"\".chanType·1 *byte, @\"\".hchan·2 chan<- any, @\"\".elem·3 *any)\n"
"func @\"\".closechan (@\"\".hchan·1 any)\n"
+ "func @\"\".writebarrierptr (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+ "func @\"\".writebarrieriface (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+ "func @\"\".writebarrierstring (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+ "func @\"\".writebarrierslice (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+ "func @\"\".writebarrierfat (@\"\".typ·1 *byte, @\"\".dst·2 *any, @\"\".src·3 *any)\n"
"func @\"\".selectnbsend (@\"\".chanType·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (? bool)\n"
"func @\"\".selectnbrecv (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".hchan·4 <-chan any) (? bool)\n"
"func @\"\".selectnbrecv2 (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".received·4 *bool, @\"\".hchan·5 <-chan any) (? bool)\n"
#include "../ld/textflag.h"
static Node* walkprint(Node*, NodeList**, int);
+static Node* writebarrierfn(char*, Type*, Type*);
+static Node* applywritebarrier(Node*, NodeList**);
static Node* mapfn(char*, Type*);
static Node* mapfndel(char*, Type*);
static Node* ascompatee1(int, Node*, Node*, NodeList**);
r = convas(nod(OAS, n->left, n->right), init);
r->dodata = n->dodata;
n = r;
+ n = applywritebarrier(n, init);
}
goto ret;
walkexprlistsafe(n->rlist, init);
ll = ascompatee(OAS, n->list, n->rlist, init);
ll = reorder3(ll);
+ for(lr = ll; lr != nil; lr = lr->next)
+ lr->n = applywritebarrier(lr->n, init);
n = liststmt(ll);
goto ret;
walkexpr(&r, init);
ll = ascompatet(n->op, n->list, &r->type, 0, init);
+ for(lr = ll; lr != nil; lr = lr->next)
+ lr->n = applywritebarrier(lr->n, init);
n = liststmt(concat(list1(r), ll));
goto ret;
static int
fncall(Node *l, Type *rt)
{
+ Node r;
+
if(l->ullman >= UINF || l->op == OINDEXMAP)
return 1;
+ r.op = 0;
+ if(needwritebarrier(l, &r))
+ return 1;
if(eqtype(l->type, rt))
return 0;
return 1;
a = nod(OAS, l, nodarg(r, fp));
a = convas(a, init);
ullmancalc(a);
- if(a->ullman >= UINF)
+ if(a->ullman >= UINF) {
+ dump("ascompatet ucount", a);
ucount++;
+ }
nn = list(nn, a);
r = structnext(&saver);
}
return mkcall1(fn, ptrto(t), nil, typename(t));
}
+static int
+isstack(Node *n)
+{
+ while(n->op == ODOT || n->op == OPAREN || n->op == OCONVNOP || n->op == OINDEX && isfixedarray(n->left->type))
+ n = n->left;
+
+ switch(n->op) {
+ case OINDREG:
+ // OINDREG only ends up in walk if it's indirect of SP.
+ return 1;
+
+ case ONAME:
+ switch(n->class) {
+ case PAUTO:
+ case PPARAM:
+ case PPARAMOUT:
+ return 1;
+ }
+ break;
+ }
+
+ return 0;
+}
+
+static int
+isglobal(Node *n)
+{
+ while(n->op == ODOT || n->op == OPAREN || n->op == OCONVNOP || n->op == OINDEX && isfixedarray(n->left->type))
+ n = n->left;
+
+ switch(n->op) {
+ case ONAME:
+ switch(n->class) {
+ case PEXTERN:
+ return 1;
+ }
+ break;
+ }
+
+ return 0;
+}
+
+// Do we need a write barrier for the assignment l = r?
+int
+needwritebarrier(Node *l, Node *r)
+{
+ if(!use_writebarrier)
+ return 0;
+
+ if(l == N || isblank(l))
+ return 0;
+
+ // No write barrier for write of non-pointers.
+ dowidth(l->type);
+ if(!haspointers(l->type))
+ return 0;
+
+ // No write barrier for write to stack.
+ if(isstack(l))
+ return 0;
+
+ // No write barrier for zeroing.
+ if(r == N)
+ return 0;
+
+ // No write barrier for initialization to constant.
+ if(r->op == OLITERAL)
+ return 0;
+
+ // No write barrier for storing static (read-only) data.
+ if(r->op == ONAME && strncmp(r->sym->name, "statictmp_", 10) == 0)
+ return 0;
+
+ // No write barrier for storing address of stack values,
+ // which are guaranteed only to be written to the stack.
+ if(r->op == OADDR && isstack(r->left))
+ return 0;
+
+ // No write barrier for storing address of global, which
+ // is live no matter what.
+ if(r->op == OADDR && isglobal(r->left))
+ return 0;
+
+ // Otherwise, be conservative and use write barrier.
+ return 1;
+}
+
+// TODO(rsc): Perhaps componentgen should run before this.
+static Node*
+applywritebarrier(Node *n, NodeList **init)
+{
+ Node *l, *r;
+
+ if(n->left && n->right && needwritebarrier(n->left, n->right)) {
+ l = nod(OADDR, n->left, N);
+ l->etype = 1; // addr does not escape
+ if(n->left->type->width == widthptr) {
+ n = mkcall1(writebarrierfn("writebarrierptr", n->left->type, n->right->type), T, init,
+ l, n->right);
+ } else if(n->left->type->etype == TSTRING) {
+ n = mkcall1(writebarrierfn("writebarrierstring", n->left->type, n->right->type), T, init,
+ l, n->right);
+ } else if(isslice(n->left->type)) {
+ n = mkcall1(writebarrierfn("writebarrierslice", n->left->type, n->right->type), T, init,
+ l, n->right);
+ } else if(isinter(n->left->type)) {
+ n = mkcall1(writebarrierfn("writebarrieriface", n->left->type, n->right->type), T, init,
+ l, n->right);
+ } else {
+ r = n->right;
+ while(r->op == OCONVNOP)
+ r = r->left;
+ r = nod(OADDR, r, N);
+ r->etype = 1; // addr does not escape
+ n = mkcall1(writebarrierfn("writebarrierfat", n->left->type, r->left->type), T, init,
+ typename(n->left->type), l, r);
+ }
+ }
+ return n;
+}
+
static Node*
convas(Node *n, NodeList **init)
{
goto out;
}
- if(eqtype(lt, rt))
- goto out;
-
- n->right = assignconv(n->right, lt, "assignment");
- walkexpr(&n->right, init);
+ if(!eqtype(lt, rt)) {
+ n->right = assignconv(n->right, lt, "assignment");
+ walkexpr(&n->right, init);
+ }
out:
ullmancalc(n);
return fn;
}
+static Node*
+writebarrierfn(char *name, Type *l, Type *r)
+{
+ Node *fn;
+
+ fn = syslook(name, 1);
+ argtype(fn, l);
+ argtype(fn, r);
+ return fn;
+}
+
static Node*
addstr(Node *n, NodeList **init)
{