code review 116060043: cmd/gc: mark auxiliary symbols as containing no pointers

src/cmd/gc/reflect.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include <u.h>
 #include <libc.h>
 #include "go.h"
+#include "../ld/textflag.h"
 #include "../../pkg/runtime/mgc0.h"
 
 /*
  * runtime interface and reflection data structures
  */
 
 static  NodeList*       signatlist;
 static  Sym*    dtypesym(Type*);
 static  Sym*    weaktypesym(Type*);
 static  Sym*    dalgsym(Type*);
@@ skipping 499 matching lines @@
         nam = smprint("importpath.%s.", p->prefix);
 
         n = nod(ONAME, N, N);
         n->sym = pkglookup(nam, gopkg);
         free(nam);
         n->class = PEXTERN;
         n->xoffset = 0;
         p->pathsym = n->sym;
 
         gdatastring(n, p->path);
-        ggloblsym(n->sym, types[TSTRING]->width, 1, 1);
+        ggloblsym(n->sym, types[TSTRING]->width, DUPOK|RODATA);
 }
 
 static int
 dgopkgpath(Sym *s, int ot, Pkg *pkg)
 {
         if(pkg == nil)
                 return dgostringptr(s, ot, nil);
 
         // Emit reference to go.importpath.""., which 6l will
         // rewrite using the correct import path.  Every package
@@ skipping 430 matching lines @@
         if(s->flags & SymSiggen)
                 return s;
         s->flags |= SymSiggen;
 
         // special case (look for runtime below):
         // when compiling package runtime,
         // emit the type structures for int, float, etc.
         tbase = t;
         if(isptr[t->etype] && t->sym == S && t->type->sym != S)
                 tbase = t->type;
-        dupok = tbase->sym == S;
+        dupok = 0;
+        if(tbase->sym == S)
+                dupok = DUPOK;
 
         if(compiling_runtime &&
                         (tbase == types[tbase->etype] ||
                         tbase == bytetype ||
                         tbase == runetype ||
                         tbase == errortype)) { // int, float, etc
                 goto ok;
         }
 
         // named types from other files are defined only by those files
@@ skipping 154 matching lines @@
                                 else
                                         ot = dgostringptr(s, ot, nil);
                         }
                         ot = dsymptr(s, ot, dtypesym(t1->type), 0);
                         ot = dgostrlitptr(s, ot, t1->note);
                         ot = duintptr(s, ot, t1->width);        // field offset
                 }
                 break;
         }
         ot = dextratype(s, ot, t, xt);
-        ggloblsym(s, ot, dupok, 1);
+        ggloblsym(s, ot, dupok|RODATA);
 
         // generate typelink.foo pointing at s = type.foo.
         // The linker will leave a table of all the typelinks for
         // types in the binary, so reflect can find them.
         // We only need the link for unnamed composites that
         // we want be able to find.
         if(t->sym == S) {
                 switch(t->etype) {
                 case TARRAY:
                 case TCHAN:
                 case TMAP:
                         slink = typelinksym(t);
                         dsymptr(slink, 0, s, 0);
-                        ggloblsym(slink, widthptr, dupok, 1);
+                        ggloblsym(slink, widthptr, dupok|RODATA);
                 }
         }
 
         return s;
 }
 
 void
 dumptypestructs(void)
 {
         int i;
@@ skipping 82 matching lines @@
         case 1:
         case 2:
         case 4:
         case 8:
         case 16:
                 snprint(buf, sizeof buf, "memcopy%d", (int)t->width*8);
                 ot = dsymptr(s, ot, pkglookup(buf, runtimepkg), 0);
                 break;
         }
 
-        ggloblsym(s, ot, 1, 1);
+        ggloblsym(s, ot, DUPOK|RODATA);
         return s;
 }
 
 static int
 gcinline(Type *t)
 {
         switch(t->etype) {
         case TARRAY:
                 if(t->bound == 1)
                         return 1;
@@ skipping 201 matching lines @@
         s->flags |= SymGcgen;
 
         if(t->width == BADWIDTH)
                 dowidth(t);
 
         ot = 0;
         off = 0;
         ot = duintptr(s, ot, t->width);
         ot = dgcsym1(s, ot, t, &off, 0);
         ot = duintptr(s, ot, GC_END);
-        ggloblsym(s, ot, 1, 1);
+        ggloblsym(s, ot, DUPOK|RODATA);
 
         if(t->align > 0)
                 off = rnd(off, t->align);
         if(off != t->width)
                 fatal("dgcsym: off=%lld, size=%lld, type %T", off, t->width, t);
 
         return s;
 }