static void strlabel(Cfg *cfg, char *lbl, Bb *bb) { if (htget(cfg->lblmap, lbl) != bb) { htput(cfg->lblmap, lbl, bb); lappend(&bb->lbls, &bb->nlbls, lbl); } }
static void fixtypemappings(Stab *st) { size_t i; Type *t, *old; /* * merge duplicate definitions. * This allows us to compare named types by id, instead * of doing a deep walk through the type. This ability is * depended on when we do type inference. */ for (i = 0; i < ntypefixdest; i++) { t = htget(tidmap, itop(typefixid[i])); if (!t) die("Unable to find type for id %zd\n", typefixid[i]); *typefixdest[i] = t; } for (i = 0; i < ntypefixdest; i++) { old = *typefixdest[i]; if (old->type == Tyname || old->type == Tygeneric) { t = htget(tydedup, old); if (!t) { t = old; htput(tydedup, old, old); } *typefixdest[i] = t; } } /* check for duplicate type definitions */ for (i = 0; i < ntypefixdest; i++) { t = htget(tidmap, itop(typefixid[i])); if ((t->type != Tyname && t->type != Tygeneric) || t->issynth) continue; old = htget(tydedup, t); if (old && !tyeq(t, old) && !isspecialization(t, old)) lfatal(t->loc, "Duplicate definition of type %s on %s:%d", tystr(old), file->file.files[old->loc.file], old->loc.line); } for (i = 0; i < ntypefixdest; i++) lfree(&typefixdest, &ntypefixdest); lfree(&typefixid, &ntypefixid); }
void dumpfilestabs(Node *file, int depth, FILE *fd) { size_t nk, i; void **k; k = htkeys(file->file.ns, &nk); for (i = 0; i < nk; i++) { outstab(htget(file->file.ns, k[i]), fd, depth); } free(k); }
void genstrings(FILE *fd, Htab *strtab) { void **k; Str *s; size_t i, nk; k = htkeys(strtab, &nk); for (i = 0; i < nk; i++) { s = k[i]; fprintf(fd, "%s:\n", (char*)htget(strtab, k[i])); writebytes(fd, s->buf, s->len); } }
static void genblob(FILE *fd, Node *blob, Htab *globls, Htab *strtab) { char *lbl; Blob *b; /* lits and such also get wrapped in decls */ assert(blob->type == Ndecl); lbl = htget(globls, blob); fprintf(fd, "GLOBL %s+0(SB),$%zd\n", lbl, size(blob)); if (blob->decl.init) b = litblob(globls, strtab, blob->decl.init); else b = mkblobpad(size(blob)); writeblob(fd, b, 0, lbl); }
static void genstrings(FILE *fd, Htab *strtab) { void **k; char *lbl; Str *s; size_t i, nk; k = htkeys(strtab, &nk); for (i = 0; i < nk; i++) { s = k[i]; lbl = htget(strtab, k[i]); if (s->len) { fprintf(fd, "GLOBL %s+0(SB),$%lld\n", lbl, (vlong)s->len); writebytes(fd, lbl, 0, s->buf, s->len); } } }
void genblob(FILE *fd, Node *blob, Htab *globls, Htab *strtab) { char *lbl; Blob *b; /* lits and such also get wrapped in decls */ assert(blob->type == Ndecl); lbl = htget(globls, blob); if (blob->decl.vis != Visintern) fprintf(fd, ".globl %s\n", lbl); if (blob->decl.init) { fprintf(fd, ".align %zd\n", tyalign(decltype(blob))); fprintf(fd, "%s:\n", lbl); b = litblob(globls, strtab, blob->decl.init); writeblob(fd, b); blobfree(b); } else {
static Node * traitfn(Srcloc loc, Trait *tr, char *fn, Type *ty) { Node *proto, *dcl, *var; char *name; size_t i; for (i = 0; i < tr->nproto; i++) { name = declname(tr->proto[i]); if (!strcmp(fn, name)) { proto = tr->proto[i]; dcl = htget(proto->decl.impls, ty); var = mkexpr(loc, Ovar, dcl->decl.name, NULL); var->expr.type = dcl->decl.type; var->expr.did = dcl->decl.did; return var; } } return NULL; }
static void fixtraitmappings(Stab *st) { size_t i; Trait *t; /* * merge duplicate definitions. * This allows us to compare named types by id, instead * of doing a deep walk through the type. This ability is * depended on when we do type inference. */ for (i = 0; i < ntraitfixdest; i++) { t = htget(trmap, itop(traitfixid[i])); if (!t) die("Unable to find trait for id %zd\n", traitfixid[i]); if (traitfixdest[i]) *traitfixdest[i] = t; if (traitfixtype[i]) settrait(traitfixtype[i], t); } lfree(&traitfixdest, &ntraitfixdest); lfree(&traitfixid, &ntraitfixid); }