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--;
}
}
