ir_save.c

/*
 * IR - Lightweight JIT Compilation Framework
 * (IR saver)
 * This file is part of the IR Project distributed under the MIT-style LICENSE.
 * Authors: Dmitry Stogov <dmitry@php.net>
 */

#include "ir.h"
#include "ir_private.h"

void ir_print_proto(const ir_ctx *ctx, ir_ref func_proto, FILE *f)
{
	if (func_proto) {
		const ir_proto_t *proto = (const ir_proto_t *)ir_get_str(ctx, func_proto);
		ir_print_proto_ex(proto->flags, proto->ret_type, proto->params_count, proto->param_types, f);
	} else {
		fprintf(f, "(): int32_t");
	}
}

static void ir_print_call_conv(uint32_t flags, FILE *f)
{
	switch (flags & IR_CALL_CONV_MASK) {
		case IR_CC_BUILTIN:
			fprintf(f, " __builtin");
			break;
		case IR_CC_FASTCALL:
			fprintf(f, " __fastcall");
			break;
		case IR_CC_PRESERVE_NONE:
			fprintf(f, " __preserve_none");
			break;
#if defined(IR_TARGET_X64)
		case IR_CC_X86_64_SYSV:
			fprintf(f, " __sysv");
			break;
		case IR_CC_X86_64_MS:
			fprintf(f, " __win64");
			break;
#elif defined(IR_TARGET_AARCH64)
		case IR_CC_AARCH64_SYSV:
			fprintf(f, " __sysv");
			break;
		case IR_CC_AARCH64_DARWIN:
			fprintf(f, " __darwin");
			break;
#endif
		default:
			IR_ASSERT((flags & IR_CALL_CONV_MASK) == IR_CC_DEFAULT);
	}
}

void ir_print_type_cname(ir_type type, FILE *f)
{
	if (IR_IS_TYPE_VECTOR(type)) {
		fprintf(f, "<%s*%d>", ir_type_cname[IR_VECTOR_BASE_TYPE(type)], IR_VECTOR_LENGTH(type));
	} else {
		fprintf(f, "%s", ir_type_cname[type]);
	}
}

void ir_print_proto_ex(uint8_t flags, ir_type ret_type, uint32_t params_count, const uint8_t *param_types, FILE *f)
{
	uint32_t j;

	fprintf(f, "(");
	if (params_count > 0) {
		ir_print_type_cname(param_types[0], f);
		for (j = 1; j < params_count; j++) {
			fprintf(f, ", ");
			ir_print_type_cname(param_types[j], f);
		}
		if (flags & IR_VARARG_FUNC) {
			fprintf(f, ", ...");
		}
	} else if (flags & IR_VARARG_FUNC) {
		fprintf(f, "...");
	}
	fprintf(f, "): ");
	ir_print_type_cname(ret_type, f);
	ir_print_call_conv(flags, f);
	if (flags & IR_CONST_FUNC) {
		fprintf(f, " __const");
	} else if (flags & IR_PURE_FUNC) {
		fprintf(f, " __pure");
	}
}

void ir_print_func_proto(const ir_ctx *ctx, const char *name, bool prefix, FILE *f)
{
	if (ctx->flags & IR_STATIC) {
		fprintf(f, "static ");
	}
	fprintf(f, "func %s%s(",
		prefix ? "@" : "",
		name);
	if (ctx->ir_base[2].op == IR_PARAM) {
		ir_insn *insn = &ctx->ir_base[2];

		ir_print_type_cname(insn->type, f);
		insn++;
		while (insn->op == IR_PARAM) {
			fprintf(f, ", ");
			ir_print_type_cname(insn->type, f);
			insn++;;
		}
		if (ctx->flags & IR_VARARG_FUNC) {
			fprintf(f, ", ...");
		}
	} else if (ctx->flags & IR_VARARG_FUNC) {
		fprintf(f, "...");
	}
	fprintf(f, "): ");
	ir_print_type_cname(ctx->ret_type != (ir_type)-1 ? ctx->ret_type : IR_VOID, f);
	ir_print_call_conv(ctx->flags, f);
	if (ctx->flags & IR_CONST_FUNC) {
		fprintf(f, " __const");
	} else if (ctx->flags & IR_PURE_FUNC) {
		fprintf(f, " __pure");
	}
}

static void ir_save_dessa_moves(const ir_ctx *ctx, int b, ir_block *bb, FILE *f)
{
	uint32_t succ;
	ir_block *succ_bb;
	ir_use_list *use_list;
	ir_ref k, i, *p, use_ref, input;
	ir_insn *use_insn;

	IR_ASSERT(bb->successors_count == 1);
	succ = ctx->cfg_edges[bb->successors];
	succ_bb = &ctx->cfg_blocks[succ];
	IR_ASSERT(succ_bb->predecessors_count > 1);
	use_list = &ctx->use_lists[succ_bb->start];
	k = ir_phi_input_number(ctx, succ_bb, b);

	for (i = use_list->count, p = &ctx->use_edges[use_list->refs]; i > 0; p++, i--) {
		use_ref = *p;
		use_insn = &ctx->ir_base[use_ref];
		if (use_insn->op == IR_PHI) {
			input = ir_insn_op(use_insn, k);
			if (IR_IS_CONST_REF(input)) {
				fprintf(f, "\t# DESSA MOV c_%d", -input);
			} else if (ctx->vregs[input] != ctx->vregs[use_ref]) {
				fprintf(f, "\t# DESSA MOV d_%d {R%d}", input, ctx->vregs[input]);
			} else {
				continue;
			}
			if (ctx->regs) {
				int8_t *regs = ctx->regs[use_ref];
				int8_t reg = regs[k];
				if (reg != IR_REG_NONE) {
					ir_dump_reg(ctx, reg, input, 0, f);
				}
			}
			fprintf(f, " -> d_%d {R%d}", use_ref, ctx->vregs[use_ref]);
			if (ctx->regs) {
				int8_t reg = ctx->regs[use_ref][0];
				if (reg != IR_REG_NONE) {
					ir_dump_reg(ctx, reg, use_ref, 1, f);
				}
			}
			fprintf(f, "\n");
		}
	}
}

void ir_save(const ir_ctx *ctx, uint32_t save_flags, FILE *f)
{
	ir_ref i, j, n, ref, *p;
	ir_insn *insn;
	uint32_t flags;
	bool first;

	fprintf(f, "{\n");
	/* Separate behavior to keep tests compatibility. TODO: remove the old behavior */
	if (ctx->flags2 & IR_HAS_LONG_CONSTANTS) {
		for (i = 1 - ctx->consts_count, insn = ctx->ir_base + i; i < IR_UNUSED; i++, insn++) {
			fprintf(f, "\t");
			ir_print_type_cname(insn->type, f);
			fprintf(f, " c_%d = ", -i);
			if (insn->op == IR_FUNC) {
				fprintf(f, "func %s%s",
					(save_flags & IR_SAVE_SAFE_NAMES) ? "@" : "",
					ir_get_str(ctx, insn->val.name));
				ir_print_proto(ctx, insn->proto, f);
			} else if (insn->op == IR_SYM) {
				fprintf(f, "sym(%s%s)",
					(save_flags & IR_SAVE_SAFE_NAMES) ? "@" : "",
					ir_get_str(ctx, insn->val.name));
			} else if (insn->op == IR_LABEL) {
				fprintf(f, "label(%s%s)",
					(save_flags & IR_SAVE_SAFE_NAMES) ? "@" : "",
					ir_get_str(ctx, insn->val.name));
			} else if (insn->op == IR_FUNC_ADDR) {
				fprintf(f, "func *");
				ir_print_const(ctx, insn, f, true);
				ir_print_proto(ctx, insn->proto, f);
			} else {
				ir_print_const(ctx, insn, f, true);
			}
			fprintf(f, ";\n");
			if (insn->op == IR_LONG_CONST) {
				i += IR_ALIGNED_SIZE(insn->long_const_size, sizeof(ir_insn)) / sizeof(ir_insn);
				insn += IR_ALIGNED_SIZE(insn->long_const_size, sizeof(ir_insn)) / sizeof(ir_insn);
			}
		}
	} else {
		for (i = IR_UNUSED + 1, insn = ctx->ir_base - i; i < ctx->consts_count; i++, insn--) {
			fprintf(f, "\t");
			ir_print_type_cname(insn->type, f);
			fprintf(f, " c_%d = ", i);
			if (insn->op == IR_FUNC) {
				fprintf(f, "func %s%s",
					(save_flags & IR_SAVE_SAFE_NAMES) ? "@" : "",
					ir_get_str(ctx, insn->val.name));
				ir_print_proto(ctx, insn->proto, f);
			} else if (insn->op == IR_SYM) {
				fprintf(f, "sym(%s%s)",
					(save_flags & IR_SAVE_SAFE_NAMES) ? "@" : "",
					ir_get_str(ctx, insn->val.name));
			} else if (insn->op == IR_LABEL) {
				fprintf(f, "label(%s%s)",
					(save_flags & IR_SAVE_SAFE_NAMES) ? "@" : "",
					ir_get_str(ctx, insn->val.name));
			} else if (insn->op == IR_FUNC_ADDR) {
				fprintf(f, "func *");
				ir_print_const(ctx, insn, f, true);
				ir_print_proto(ctx, insn->proto, f);
			} else {
				ir_print_const(ctx, insn, f, true);
			}
			fprintf(f, ";\n");
		}
	}

	for (i = IR_UNUSED + 1, insn = ctx->ir_base + i; i < ctx->insns_count;) {
		flags = ir_op_flags[insn->op];

		if ((save_flags & IR_SAVE_CFG)
		 && ctx->cfg_map
		 && (int32_t)ctx->cfg_map[i] > 0 /* the node may be scheduled incompletely */
		 && ctx->cfg_blocks[ctx->cfg_map[i]].start == i) {
			uint32_t b = ctx->cfg_map[i];
			ir_block *bb = &ctx->cfg_blocks[b];
			fprintf(f, "#BB%d: end=l_%d", b, bb->end);
			if (bb->flags & IR_BB_UNREACHABLE) {
				fprintf(f, ", U");
			}
			if (bb->dom_parent > 0) {
				fprintf(f, ", idom=BB%d(%d)", bb->dom_parent, bb->dom_depth);
			}
			if (bb->loop_depth != 0) {
				if (bb->flags & IR_BB_LOOP_HEADER) {
					if (bb->loop_header > 0) {
						fprintf(f, ", loop=HDR,BB%d(%d)", bb->loop_header, bb->loop_depth);
					} else {
						IR_ASSERT(bb->loop_depth == 1);
						fprintf(f, ", loop=HDR(%d)", bb->loop_depth);
					}
				} else {
					IR_ASSERT(bb->loop_header > 0);
					fprintf(f, ", loop=BB%d(%d)", bb->loop_header, bb->loop_depth);
				}
			}
			if (bb->flags & IR_BB_IRREDUCIBLE_LOOP) {
				fprintf(f, ", IRREDUCIBLE");
			}
			if (bb->flags & IR_BB_IRREDUCIBLE_ENTRY) {
				fprintf(f, ", IRREDUCIBLE_ENTRY");
			}
			if (bb->predecessors_count) {
				uint32_t i;

				fprintf(f, ", pred(%d)=[BB%d", bb->predecessors_count, ctx->cfg_edges[bb->predecessors]);
				for (i = 1; i < bb->predecessors_count; i++) {
					fprintf(f, ", BB%d", ctx->cfg_edges[bb->predecessors + i]);
				}
				fprintf(f, "]");
			}
			if (bb->successors_count) {
				uint32_t i;

				fprintf(f, ", succ(%d)=[BB%d", bb->successors_count, ctx->cfg_edges[bb->successors]);
				for (i = 1; i < bb->successors_count; i++) {
					fprintf(f, ", BB%d", ctx->cfg_edges[bb->successors + i]);
				}
				fprintf(f, "]");
			}
			fprintf(f, "\n");
		}

		if (flags & IR_OP_FLAG_CONTROL) {
			if (!(flags & IR_OP_FLAG_MEM) || insn->type == IR_VOID) {
				fprintf(f, "\tl_%d = ", i);
			} else {
				fprintf(f, "\t");
				ir_print_type_cname(insn->type, f);
				fprintf(f, " d_%d", i);
				if (save_flags & IR_SAVE_REGS) {
					if (ctx->vregs && ctx->vregs[i] > 0) {
						fprintf(f, " {R%d}", ctx->vregs[i]);
					}
					if (ctx->regs) {
						int8_t reg = ctx->regs[i][0];
						if (reg != IR_REG_NONE) {
							ir_dump_reg(ctx, reg, i, 1, f);
						}
					}
				}
				fprintf(f, ", l_%d = ", i);
			}
		} else {
			fprintf(f, "\t");
			if (flags & IR_OP_FLAG_DATA) {
				ir_print_type_cname(insn->type, f);
				fprintf(f, " d_%d", i);
				if (save_flags & IR_SAVE_REGS) {
					if (ctx->vregs && ctx->vregs[i] > 0) {
						fprintf(f, " {R%d}", ctx->vregs[i]);
					}
					if (ctx->regs) {
						int8_t reg = ctx->regs[i][0];
						if (reg != IR_REG_NONE) {
							ir_dump_reg(ctx, reg, i, 1, f);
						}
					}
				}
				fprintf(f, " = ");
			}
		}
		fprintf(f, "%s", ir_op_name[insn->op]);
		n = ir_operands_count(ctx, insn);
		if ((insn->op == IR_MERGE || insn->op == IR_LOOP_BEGIN) && n != 2) {
			fprintf(f, "/%d", n);
		} else if ((insn->op == IR_CALL || insn->op == IR_TAILCALL || insn->op == IR_ASM) && n != 2) {
			fprintf(f, "/%d", n - 2);
		} else if (insn->op == IR_PHI && n != 3) {
			fprintf(f, "/%d", n - 1);
		} else if (insn->op == IR_SNAPSHOT) {
			fprintf(f, "/%d", n - 1);
		}
		first = 1;
		for (j = 1, p = insn->ops + 1; j <= n; j++, p++) {
			uint32_t opnd_kind = IR_OPND_KIND(flags, j);

			ref = *p;
			if (ref) {
				switch (opnd_kind) {
					case IR_OPND_DATA:
						if (IR_IS_CONST_REF(ref)) {
							fprintf(f, "%sc_%d", first ? "(" : ", ", -ref);
						} else {
							fprintf(f, "%sd_%d", first ? "(" : ", ", ref);
						}
						if (save_flags & IR_SAVE_REGS) {
							if (ctx->vregs && ref > 0 && ctx->vregs[ref] > 0) {
								fprintf(f, " {R%d}", ctx->vregs[ref]);
							}
							if (ctx->regs) {
								int8_t *regs = ctx->regs[i];
								int8_t reg = regs[j];
								if (reg != IR_REG_NONE) {
									ir_dump_reg(ctx, reg, ref, 0, f);
								}
							}
						}
						first = 0;
						break;
					case IR_OPND_CONTROL:
					case IR_OPND_CONTROL_DEP:
					case IR_OPND_CONTROL_REF:
					case IR_OPND_CONTROL_GUARD:
						fprintf(f, "%sl_%d", first ? "(" : ", ", ref);
						first = 0;
						break;
					case IR_OPND_STR:
						fprintf(f, "%s\"%s\"", first ? "(" : ", ", ir_get_str(ctx, ref));
						first = 0;
						break;
					case IR_OPND_PROTO:
						fprintf(f, "%sfunc ", first ? "(" : ", ");
						ir_print_proto(ctx, ref, f);
						break;
					case IR_OPND_OPT:
						if (ref == 0) {
							break;
						}
						IR_FALLTHROUGH;
					case IR_OPND_NUM:
						fprintf(f, "%s%d", first ? "(" : ", ", ref);
						first = 0;
						break;
					case IR_OPND_LABEL_REF:
						if (ref) {
							IR_ASSERT(IR_IS_CONST_REF(ref));
							fprintf(f, "%sc_%d", first ? "(" : ", ", -ref);
							first = 0;
						}
						break;
				}
			} else if (opnd_kind == IR_OPND_NUM) {
				fprintf(f, "%s%d", first ? "(" : ", ", ref);
				first = 0;
			} else if (opnd_kind == IR_OPND_CONTROL_GUARD) {
				/* skip */
			} else if (j != n &&
					(IR_IS_REF_OPND_KIND(opnd_kind) || (opnd_kind == IR_OPND_UNUSED && p[n-j]))) {
				fprintf(f, "%snull", first ? "(" : ", ");
				first = 0;
			}
		}
		if (first) {
			fprintf(f, ";");
		} else if (ctx->value_params
		 && insn->op == IR_PARAM
		 && ctx->value_params[insn->op3 - 1].align) {
			fprintf(f, ") ByVal(%d, %d);",
				ctx->value_params[insn->op3 - 1].size,
				ctx->value_params[insn->op3 - 1].align);
		} else {
			fprintf(f, ");");
		}
		first = 1;
		if (((flags & IR_OP_FLAG_DATA) || ((flags & IR_OP_FLAG_MEM) && insn->type != IR_VOID)) && ctx->binding) {
			ir_ref var = ir_binding_find(ctx, i);
			if (var) {
				IR_ASSERT(var < 0);
				fprintf(f, " # BIND(0x%x);", -var);
				first = 0;
			}
		}

		if ((save_flags & IR_SAVE_CFG_MAP)
		 && ctx->cfg_map
		 && ctx->cfg_map[i] > 0) { /* the node may be scheduled incompletely */
			if (first) {
				fprintf(f, " #");
				first = 0;
			}
			fprintf(f, " BLOCK=BB%d;", ctx->cfg_map[i]);
		}

		if ((save_flags & IR_SAVE_RULES)
		 && ctx->rules) {
			uint32_t rule = ctx->rules[i];
			uint32_t id = rule & IR_RULE_MASK;

			if (first) {
				fprintf(f, " #");
				first = 0;
			}
			if (id < IR_LAST_OP) {
				fprintf(f, " RULE(%s", ir_op_name[id]);
			} else {
				IR_ASSERT(id > IR_LAST_OP /*&& id < IR_LAST_RULE*/);
				fprintf(f, " RULE(%s", ir_rule_name[id - IR_LAST_OP]);
			}
			if (rule & IR_FUSED) {
				fprintf(f, ":FUSED");
			}
			if (rule & IR_SKIPPED) {
				fprintf(f, ":SKIPPED");
			}
			if (rule & IR_SIMPLE) {
				fprintf(f, ":SIMPLE");
			}
#if IR_X86_I64
			if (rule & IR_TWO_REGS) {
				fprintf(f, ":TWO_REGS");
			}
#endif
			fprintf(f, ");");
		}

		if ((save_flags & IR_SAVE_USE_LISTS)
		 && ctx->use_lists
		 && ctx->use_lists[i].count) {
			ir_use_list *use_list = &ctx->use_lists[i];
			ir_ref n = use_list->count;
			ir_ref *p = ctx->use_edges + use_list->refs;

			if (first) {
				fprintf(f, " #");
				first = 0;
			}
			fprintf(f, " USE_LIST(%d)=[%05d", n, *p);
			for (p++, n--; n; p++, n--) {
				fprintf(f, ", %05d", *p);
			}
			fprintf(f, "];");
		}
		fprintf(f, "\n");

		if ((save_flags & (IR_SAVE_CFG|IR_SAVE_REGS)) == (IR_SAVE_CFG|IR_SAVE_REGS)
		 && ctx->cfg_map
		 && ctx->cfg_map[i]
		 && ctx->cfg_blocks[ctx->cfg_map[i]].end == i) {
			uint32_t b = ctx->cfg_map[i];
			ir_block *bb = &ctx->cfg_blocks[b];
			if (bb->flags & IR_BB_DESSA_MOVES) {
				ir_save_dessa_moves(ctx, b, bb, f);
			}
		}

		n = ir_insn_inputs_to_len(n);
		i += n;
		insn += n;
	}
	fprintf(f, "}\n");
}