code review 5316043: gc: clean up printing.

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"
 
 /*
  * runtime interface and reflection data structures
@@ skipping 575 matching lines @@
         ot = duint8(s, ot, algtype(t));
         ot = duint8(s, ot, t->align);   // align
         ot = duint8(s, ot, t->align);   // fieldAlign
         i = kinds[t->etype];
         if(t->etype == TARRAY && t->bound < 0)
                 i = KindSlice;
         if(!haspointers(t))
                 i |= KindNoPointers;
         ot = duint8(s, ot, i);  // kind
         p = smprint("%-uT", t);
-//      print("dcommontype %s\n", p);
+        //print("dcommontype: %s\n", p);
         ot = dgostringptr(s, ot, p);    // string
         free(p);
 ········
         // skip pointer to extraType,
         // which follows the rest of this type structure.
         // caller will fill in if needed.
         // otherwise linker will assume 0.
         ot += widthptr;
 
         ot = dsymptr(s, ot, sptr, 0);  // ptrto type
         return ot;
 }
 
 Sym*
 typesym(Type *t)
 {
         char *p;
         Sym *s;
 
         p = smprint("%-T", t);
         s = pkglookup(p, typepkg);
-//      print("typesym %s -> %+S\n", p, s);
+        //print("typesym: %s -> %+S\n", p, s);
         free(p);
         return s;
 }
 
 Node*
 typename(Type *t)
 {
         Sym *s;
         Node *n;
 
@@ skipping 28 matching lines @@
         static Pkg *weak;
 ········
         if(weak == nil) {
                 weak = mkpkg(strlit("weak.type"));
                 weak->name = "weak.type";
                 weak->prefix = "weak.type";  // not weak%2etype
         }
 ········
         p = smprint("%-T", t);
         s = pkglookup(p, weak);
-//      print("weaktypesym %s -> %+S\n", p, s);
+        //print("weaktypesym: %s -> %+S\n", p, s);
         free(p);
         return s;
 }
 
 static Sym*
 dtypesym(Type *t)
 {
         int ot, xt, n, isddd, dupok;
         Sym *s, *s1, *s2;
         Sig *a, *m;
         Type *t1, *tbase, *t2;
 
         if(isideal(t))
                 fatal("dtypesym %T", t);
 
         s = typesym(t);
         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;
 
-        if(compiling_runtime && tbase == types[tbase->etype])   // int, float, etc
+        if(compiling_runtime && (tbase == types[tbase->etype] || tbase == bytetype || tbase == runetype))       // int, float, etc
                 goto ok;
 
         // named types from other files are defined only by those files
         if(tbase->sym && !tbase->local)
                 return s;
         if(isforw[tbase->etype])
                 return s;
 
 ok:
         ot = 0;
@@ skipping 195 matching lines @@
                 for(i=1; i<=TBOOL; i++)
                         dtypesym(ptrto(types[i]));
                 dtypesym(ptrto(types[TSTRING]));
                 dtypesym(ptrto(types[TUNSAFEPTR]));
 ················
                 // add paths for runtime and main, which 6l imports implicitly.
                 dimportpath(runtimepkg);
                 dimportpath(mkpkg(strlit("main")));
         }
 }