void symstr_component_dump(struct symstr_component *sc) { if (sc->alphasym == NULL) { if (sc->op == SYMSTR_OP_NOP) { symbol_print(sc->sym); } else { fprintf(stderr, "("); if (sc->op == SYMSTR_OP_PRED) fprintf(stderr, "pred "); else if (sc->op == SYMSTR_OP_SUCC) fprintf(stderr, "succ "); else if (sc->op == SYMSTR_OP_PREV) fprintf(stderr, "prev "); else if (sc->op == SYMSTR_OP_NEXT) fprintf(stderr, "next "); symbol_print(sc->sym); if (sc->fmode != NULL) { fprintf(stderr, " | "); symstr_components_dump(sc->fmode->head); } fprintf(stderr, ")"); } } else { fprintf(stderr, "("); symbol_print(sc->sym); fprintf(stderr, " = "); symbol_print(sc->alphasym); if (sc->many) fprintf(stderr, "+"); fprintf(stderr, ")"); } }
void expr_resolve( struct expr *e ) { if (!e) return; expr_resolve(e->left); expr_resolve(e->right); if (e->kind == EXPR_NAME) { struct symbol *s = scope_lookup(e->name); if (s) { e->symbol = s; printf("%s resovles to ", e->name ); symbol_print( s ); printf("\n"); } else { printf("variable %s not defined\n", e->name); exit(1); } } if (e->kind == EXPR_FUNCTION_VAL) { struct symbol *s = scope_lookup(e->name); if (s) { e->symbol = s; printf("%s resovles to ", e->name ); symbol_print( s ); printf("\n"); } else { printf("variable function %s not defined\n", e->name); exit(1); } } expr_resolve(e->next); }
void symbol_table_dump(Symbol *symtab) { Symbol *temp = symtab; for (temp = symtab->next; temp != NULL; temp = temp->next) symbol_print(temp); }
void symbol_show(object_t *obj) { symbol_t *p; for (p = (symbol_t *)obj; p != NULL; p = p->next) symbol_print(p); }
void symbol_print_all(FILE* fp) { Symbol* sym; assert(fp != NULL); for(sym = anchor; sym != NULL; sym = sym->next) symbol_print(fp, sym); }
STATIC void touchlvalue(elem *e) { register int i; if (e->Eoper == OPind) /* if indirect store */ { /* NOTE: Some types of array assignments do not need * to touch all variables. (Like a[5], where a is an * array instead of a pointer.) */ touchfunc(0); return; } for (i = hcstop; --i >= 0;) { if (hcstab[i].Helem && hcstab[i].Helem->EV.sp.Vsym == e->EV.sp.Vsym) hcstab[i].Helem = NULL; } assert(e->Eoper == OPvar || e->Eoper == OPrelconst); switch (e->EV.sp.Vsym->Sclass) { case SCregpar: case SCregister: case SCtmp: case SCpseudo: break; case SCauto: case SCparameter: case SCfastpar: case SCshadowreg: case SCbprel: if (e->EV.sp.Vsym->Sflags & SFLunambig) break; /* FALL-THROUGH */ case SCstatic: case SCextern: case SCglobal: case SClocstat: case SCcomdat: case SCinline: case SCsinline: case SCeinline: case SCcomdef: touchstar(); break; default: #ifdef DEBUG elem_print(e); symbol_print(e->EV.sp.Vsym); #endif assert(0); } }
void symbol_list_print (const symbol_list *l, FILE *f) { for (/* Nothing. */; l && l->sym; l = l->next) { symbol_print (l->sym, f); fprintf (stderr, l->used ? " used" : " unused"); if (l && l->sym) fprintf (f, ", "); } }
void symbol_list_syms_print (const symbol_list *l, FILE *f) { for (/* Nothing. */; l && l->content.sym; l = l->next) { symbol_print (l->content.sym, f); fprintf (stderr, l->action_props.is_value_used ? " used" : " unused"); if (l && l->content.sym) fprintf (f, ", "); } }
STATIC int cpp_protection(symbol *s) { int i; switch (s->Sflags & SFLpmask) { case SFLprivate: i = 0; break; case SFLprotected: i = 1; break; case SFLpublic: i = 2; break; default: symbol_print(s); assert(0); } return i; }
//Resolves the name of an expression void expr_resolve(struct expr *e){ if(!e) return; expr_resolve(e->left); expr_resolve(e->right); if(e->kind == EXPR_IDENT) { e->symbol = scope_lookup(e->name); if(e->symbol) { printf("%s resolves to "); symbol_print(e->symbol); } else { //not defined in this scope e->symbol = 0; resolve_error(e->name); } } }
void symbol_list_syms_print (const symbol_list *l, FILE *f) { char const *sep = ""; for (/* Nothing. */; l && l->content.sym; l = l->next) { fputs (sep, f); fputs (l->content_type == SYMLIST_SYMBOL ? "symbol: " : l->content_type == SYMLIST_TYPE ? "type: " : "invalid content_type: ", f); symbol_print (l->content.sym, f); fputs (l->action_props.is_value_used ? " used" : " unused", f); sep = ", "; } }
void sliceStructs() { if (debugc) printf("sliceStructs()\n"); size_t sia_length = globsym.top; /* 3 is because it is used for two arrays, sia[] and sia2[]. * sia2[] can grow to twice the size of sia[], as symbols can get split into two. */ SymInfo *sia = (SymInfo *)malloc(3 * sia_length * sizeof(SymInfo)); assert(sia); SymInfo *sia2 = sia + sia_length; bool anySlice = false; for (int si = 0; si < globsym.top; si++) { Symbol *s = globsym.tab[si]; //printf("slice1: %s\n", s->Sident); if ((s->Sflags & (GTregcand | SFLunambig)) != (GTregcand | SFLunambig)) { sia[si].canSlice = false; continue; } targ_size_t sz = type_size(s->Stype); if (sz != 2 * REGSIZE || tyfv(s->Stype->Tty) || tybasic(s->Stype->Tty) == TYhptr) // because there is no TYseg { sia[si].canSlice = false; continue; } switch (s->Sclass) { case SCfastpar: case SCregister: case SCauto: case SCshadowreg: case SCparameter: anySlice = true; sia[si].canSlice = true; sia[si].accessSlice = false; // We can't slice whole XMM registers if (tyxmmreg(s->Stype->Tty) && s->Spreg >= XMM0 && s->Spreg <= XMM15 && s->Spreg2 == NOREG) { sia[si].canSlice = false; } break; case SCstack: case SCpseudo: case SCstatic: case SCbprel: sia[si].canSlice = false; break; default: symbol_print(s); assert(0); } } if (!anySlice) goto Ldone; for (block *b = startblock; b; b = b->Bnext) { if (b->BC == BCasm) goto Ldone; if (b->Belem) sliceStructs_Gather(sia, b->Belem); } { // scope needed because of goto skipping declarations bool any = false; int n = 0; // the number of symbols added for (int si = 0; si < sia_length; si++) { sia2[si + n].canSlice = false; if (sia[si].canSlice) { // If never did access it as a slice, don't slice if (!sia[si].accessSlice) { sia[si].canSlice = false; continue; } /* Split slice-able symbol sold into two symbols, * (sold,snew) in adjacent slots in the symbol table. */ Symbol *sold = globsym.tab[si + n]; size_t idlen = 2 + strlen(sold->Sident) + 2; char *id = (char *)malloc(idlen + 1); assert(id); sprintf(id, "__%s_%d", sold->Sident, REGSIZE); if (debugc) printf("creating slice symbol %s\n", id); Symbol *snew = symbol_calloc(id, idlen); free(id); snew->Sclass = sold->Sclass; snew->Sfl = sold->Sfl; snew->Sflags = sold->Sflags; if (snew->Sclass == SCfastpar || snew->Sclass == SCshadowreg) { snew->Spreg = sold->Spreg2; snew->Spreg2 = NOREG; sold->Spreg2 = NOREG; } type_free(sold->Stype); sold->Stype = type_fake(sia[si].ty0); sold->Stype->Tcount++; snew->Stype = type_fake(sia[si].ty1); snew->Stype->Tcount++; SYMIDX sinew = symbol_add(snew); for (int i = sinew; i > si + n + 1; --i) { globsym.tab[i] = globsym.tab[i - 1]; globsym.tab[i]->Ssymnum += 1; } globsym.tab[si + n + 1] = snew; snew->Ssymnum = si + n + 1; sia2[si + n].canSlice = true; sia2[si + n].si0 = si + n; sia2[si + n].ty0 = sia[si].ty0; sia2[si + n].ty1 = sia[si].ty1; ++n; any = true; } } if (!any) goto Ldone; } for (int si = 0; si < globsym.top; si++) { Symbol *s = globsym.tab[si]; assert(s->Ssymnum == si); } for (block *b = startblock; b; b = b->Bnext) { if (b->Belem) sliceStructs_Replace(sia2, b->Belem); } Ldone: free(sia); }