void gen_expr_str_funcall(expr *e, symtable *stab) { expr **iter; (void)stab; idt_printf("funcall, calling:\n"); gen_str_indent++; print_expr(e->expr); gen_str_indent--; if(e->funcargs){ int i; idt_printf("args:\n"); gen_str_indent++; for(i = 1, iter = e->funcargs; *iter; iter++, i++){ idt_printf("arg %d:\n", i); gen_str_indent++; print_expr(*iter); gen_str_indent--; } gen_str_indent--; }else{ idt_printf("no args\n"); } }
void gen_expr_str_sizeof(expr *e, symtable *stab) { (void)stab; if(e->expr->expr_is_sizeof){ idt_printf("sizeof %s\n", decl_to_str(e->expr->tree_type)); }else{ idt_printf("sizeof expr:\n"); print_expr(e->expr); } }
void print_stmt(stmt *t) { idt_printf("statement: %s\n", t->f_str()); if(t->flow){ gen_str_indent++; print_stmt_flow(t->flow); gen_str_indent--; } PRINT_IF(t, expr, print_expr); PRINT_IF(t, lhs, print_stmt); PRINT_IF(t, rhs, print_stmt); PRINT_IF(t, rhs, print_stmt); if(stmt_kind(t, code)){ idt_printf("structs/unions/enums:\n"); gen_str_indent++; print_sues_static_asserts(t->symtab); gen_str_indent--; if(t->symtab){ decl **iter; idt_printf("stack space %d\n", t->symtab->auto_total_size); idt_printf("decls:\n"); for(iter = t->symtab->decls; iter && *iter; iter++){ decl *d = *iter; gen_str_indent++; print_decl(d, PDECL_INDENT | PDECL_NEWLINE | PDECL_SYM_OFFSET | PDECL_ATTR | PDECL_PINIT); gen_str_indent--; } } if(t->bits.code.stmts){ stmt **iter; idt_printf("code:\n"); for(iter = t->bits.code.stmts; *iter; iter++){ gen_str_indent++; print_stmt(*iter); gen_str_indent--; } } } }
static void print_enum(struct_union_enum_st *et) { sue_member **mi; idt_printf("enum %s:\n", et->spel); gen_str_indent++; for(mi = et->members; *mi; mi++){ enum_member *m = (*mi)->enum_member; idt_printf("member %s = %" NUMERIC_FMT_D "\n", m->spel, const_fold_val_i(m->val)); } gen_str_indent--; }
void gen_expr_str_assign_compound(expr *e) { idt_printf("compound %s%s-assignment expr:\n", e->assign_is_post ? "post-" : "", op_to_str(e->op)); idt_printf("assign to:\n"); gen_str_indent++; print_expr(e->lhs); gen_str_indent--; idt_printf("assign from:\n"); gen_str_indent++; print_expr(e->rhs); gen_str_indent--; }
static void print_sues_static_asserts(symtable *stab) { struct_union_enum_st **sit; static_assert **stati; int nl = 0; for(sit = stab->sues; sit && *sit; sit++){ struct_union_enum_st *sue = *sit; (sue->primitive == type_enum ? print_enum : print_struct)(sue); nl = 1; } for(stati = stab->static_asserts; stati && *stati; stati++){ static_assert *sa = *stati; idt_printf("static assertion: %s\n", sa->s); gen_str_indent++; print_expr(sa->e); gen_str_indent--; nl = 1; } if(nl) fputc('\n', cc1_out); }
void gen_expr_str_struct(expr *e) { decl *mem = e->bits.struct_mem.d; idt_printf("struct/union member %s offset %d\n", mem->spel, struct_offset(e)); if(mem->bits.var.field_width) idt_printf("bitfield offset %u, width %u\n", mem->bits.var.struct_offset_bitfield, (unsigned)const_fold_val_i(mem->bits.var.field_width)); gen_str_indent++; print_expr(e->lhs); gen_str_indent--; }
void gen_expr_str_cast(expr *e, symtable *stab) { (void)stab; idt_printf("cast expr:\n"); gen_str_indent++; print_expr(e->expr); gen_str_indent--; }
void print_expr(expr *e) { idt_printf("expr: %s\n", e->f_str()); if(e->tree_type){ /* might be a label */ idt_printf("tree_type: "); gen_str_indent++; print_type(e->tree_type, NULL); gen_str_indent--; fputc('\n', cc1_out); } gen_str_indent++; if(e->f_gen) IGNORE_PRINTGEN(e->f_gen(e, NULL)); else idt_printf("builtin/%s::%s\n", e->f_str(), e->expr->bits.ident.bits.ident.spel); gen_str_indent--; }
static void print_stmt_flow(stmt_flow *t) { idt_printf("for parts:\n"); gen_str_indent++; PRINT_IF(t, for_init, print_expr); PRINT_IF(t, for_while, print_expr); PRINT_IF(t, for_inc, print_expr); gen_str_indent--; }
static void print_struct(struct_union_enum_st *sue) { sue_member **iter; if(!sue_complete(sue)){ idt_printf("incomplete %s %s\n", sue_str(sue), sue->spel); return; } idt_printf("%s %s (size %d):\n", sue_str(sue), sue->spel, sue_size(sue, &sue->where)); gen_str_indent++; for(iter = sue->members; iter && *iter; iter++){ decl *d = (*iter)->struct_member; idt_printf("decl %s:\n", d->spel ? d->spel : "<anon>"); gen_str_indent++; print_decl(d, PDECL_INDENT | PDECL_NEWLINE | PDECL_ATTR); if(!type_is(d->ref, type_func)){ #define SHOW_FIELD(nam) idt_printf("." #nam " = %u\n", d->bits.var.nam) SHOW_FIELD(struct_offset); if(d->bits.var.field_width){ integral_t v = const_fold_val_i(d->bits.var.field_width); gen_str_indent++; idt_printf(".field_width = %" NUMERIC_FMT_D "\n", v); SHOW_FIELD(struct_offset_bitfield); gen_str_indent--; } } gen_str_indent--; } gen_str_indent--; }
void gen_expr_str_if(expr *e, symtable *stab) { (void)stab; idt_printf("if expression:\n"); gen_str_indent++; #define SUB_PRINT(nam) \ do{\ idt_printf(#nam ":\n"); \ gen_str_indent++; \ print_expr(e->nam); \ gen_str_indent--; \ }while(0) SUB_PRINT(expr); if(e->lhs) SUB_PRINT(lhs); else idt_printf("?: syntactic sugar\n"); SUB_PRINT(rhs); #undef SUB_PRINT }
static void print_attribute(attribute *da) { for(; da; da = da->next){ idt_printf("__attribute__((%s))\n", attribute_to_str(da)); gen_str_indent++; switch(da->type){ case attr_section: idt_printf("section \"%s\"\n", da->bits.section); break; case attr_nonnull: { unsigned long l = da->bits.nonnull_args; idt_printf("nonnull: "); if(l == ~0UL){ fprintf(cc1_out, "all"); }else{ const char *sep = ""; int i; for(i = 0; i <= 32; i++) if(l & (1 << i)){ fprintf(cc1_out, "%s%d", sep, i); sep = ", "; } } fputc('\n', cc1_out); break; } default: break; } gen_str_indent--; } }
void gen_expr_str_str(expr *e) { FILE *f = gen_file(); stringlit *lit = e->bits.strlit.lit_at.lit; idt_printf("%sstring at %s\n", lit->wide ? "wide " : "", lit->lbl); gen_str_indent++; idt_print(); literal_print(f, e->bits.strlit.lit_at.lit->str, e->bits.strlit.lit_at.lit->len); gen_str_indent--; fputc('\n', f); }
static void print_decl_init(decl_init *di) { switch(di->type){ case decl_init_scalar: idt_printf("scalar:\n"); gen_str_indent++; print_expr(di->bits.expr); gen_str_indent--; break; case decl_init_copy: ICE("copy in print"); break; case decl_init_brace: { decl_init *s; int i; idt_printf("brace\n"); gen_str_indent++; for(i = 0; (s = di->bits.ar.inits[i]); i++){ if(s == DYNARRAY_NULL){ idt_printf("[%d] = <zero init>\n", i); }else if(s->type == decl_init_copy){ idt_printf("[%d] = copy from range_store[%ld]\n", i, (long)DECL_INIT_COPY_IDX(s, di)); }else{ const int need_brace = s->type == decl_init_brace; /* ->member not printed */ #ifdef DINIT_WITH_STRUCT if(s->spel) idt_printf(".%s", s->spel); else #endif idt_printf("[%d]", i); fprintf(cc1_out, " = %s\n", need_brace ? "{" : ""); gen_str_indent++; print_decl_init(s); gen_str_indent--; if(need_brace) idt_printf("}\n"); } } gen_str_indent--; if(di->bits.ar.range_inits){ struct init_cpy *icpy; idt_printf("range store:\n"); gen_str_indent++; for(i = 0; (icpy = di->bits.ar.range_inits[i]); i++){ idt_printf("store[%d]:\n", i); gen_str_indent++; print_decl_init(icpy->range_init); gen_str_indent--; if(icpy->first_instance){ idt_printf("first expr:\n"); gen_str_indent++; print_expr(icpy->first_instance); gen_str_indent--; } } gen_str_indent--; } } } }
void gen_expr_str_val(expr *e, symtable *stab) { (void)stab; idt_printf("val: %d\n", e->val); }
void print_decl(decl *d, enum pdeclargs mode) { if(mode & PDECL_INDENT) idt_print(); if(d->store) fprintf(cc1_out, "%s ", decl_store_to_str(d->store)); if(fopt_mode & FOPT_ENGLISH){ print_decl_eng(d); }else{ print_type(d->ref, d); } if(mode & PDECL_SYM_OFFSET){ if(d->sym){ const int off = d->sym->type == sym_arg ? d->sym->loc.arg_offset : (int)d->sym->loc.stack_pos; fprintf(cc1_out, " (sym %s, pos = %d)", sym_to_str(d->sym->type), off); }else{ fprintf(cc1_out, " (no sym)"); } } if(mode & PDECL_SIZE && !type_is(d->ref, type_func)){ if(type_is_complete(d->ref)){ const unsigned sz = decl_size(d); const unsigned align = decl_align(d); fprintf(cc1_out, " size %u, align %u", sz, align); }else{ fprintf(cc1_out, " incomplete decl"); } } if(mode & PDECL_NEWLINE) fputc('\n', cc1_out); if(!type_is(d->ref, type_func) && d->bits.var.init.dinit && mode & PDECL_PINIT) { gen_str_indent++; print_decl_init(d->bits.var.init.dinit); gen_str_indent--; } if(mode & PDECL_ATTR){ gen_str_indent++; if(!type_is(d->ref, type_func) && d->bits.var.align) idt_printf("[align={as_int=%d, resolved=%d}]\n", d->bits.var.align->as_int, d->bits.var.align->resolved); print_attribute(d->attr); print_type_attr(d->ref); gen_str_indent--; } if((mode & PDECL_FUNC_DESCEND) && DECL_HAS_FUNC_CODE(d)){ decl **iter; gen_str_indent++; for(iter = d->bits.func.code->symtab->decls; iter && *iter; iter++){ sym *s = (*iter)->sym; if(s) idt_printf("offset of %s = %d\n", (*iter)->spel, s->loc.stack_pos); } idt_printf("function stack space %d\n", d->bits.func.code->symtab->auto_total_size); print_stmt(d->bits.func.code); gen_str_indent--; } }