ply/ir.c

#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>

#include <linux/bpf.h>

#include "ir.h"
#include "sym.h"
#include "type.h"

const uint16_t vreg_base = 0x8000;

static const char *bpf_func_name(enum bpf_func_id id)
{
	switch (id) {
	case BPF_FUNC_get_current_comm:
		return "get_current_comm";
	case BPF_FUNC_get_current_pid_tgid:
		return "get_current_pid_tgid";
	case BPF_FUNC_get_current_uid_gid:
		return "get_current_uid_gid";
	case BPF_FUNC_get_stackid:
		return "get_stackid";
	case BPF_FUNC_ktime_get_ns:
		return "ktime_get_ns";
	case BPF_FUNC_map_delete_elem:
		return "map_delete_elem";
	case BPF_FUNC_map_lookup_elem:
		return "map_lookup_elem";
	case BPF_FUNC_map_update_elem:
		return "map_update_elem";
	case BPF_FUNC_perf_event_output:
		return "perf_event_output";
	case BPF_FUNC_probe_read:
		return "probe_read";
	case BPF_FUNC_trace_printk:
		return "trace_printk";
	default:
		return NULL;
	}
}

static void reg_name(uint16_t reg, char *name)
{
        if (reg & vreg_base) {
		sprintf(name, "v%u", reg & ~vreg_base);		
	} else if (reg == BPF_REG_10) {
		strcpy(name, "bp");
	} else {
		sprintf(name, "r%u", reg);
	}
}

static void reg_dump(uint16_t reg, int16_t off, FILE *fp)
{
	char name[8];

	reg_name(reg, name);

	if (off < 0)
		fprintf(fp, "[%s - 0x%x]", name, -off);
	else if (off > 0)
		fprintf(fp, "[%s + 0x%x]", name, off);
	else
		fprintf(fp, "%s", name);
}

static char size_name(uint8_t code)
{
	switch (BPF_SIZE(code)) {
	case BPF_B:  return 'b';
	case BPF_H:  return 'h';
	case BPF_W:  return 'w';
	case BPF_DW: return 'q';
	}

	return '?';
}		

static void alu_dump(uint8_t code, FILE *fp)
{
	switch (BPF_OP(code)) {
	case BPF_MOV: fputs("mov", fp); break;
	case BPF_ADD: fputs("add", fp); break;
	case BPF_SUB: fputs("sub", fp); break;
	case BPF_MUL: fputs("mul", fp); break;
	case BPF_DIV: fputs("div", fp); break;
	case BPF_OR : fputs("or",  fp); break;
	case BPF_AND: fputs("and", fp); break;
	case BPF_LSH: fputs("lsh", fp); break;
	case BPF_RSH: fputs("rsh", fp); break;
	case BPF_NEG: fputs("neg", fp); break;
	case BPF_MOD: fputs("mod", fp); break;
	case BPF_XOR: fputs("xor", fp); break;
	}

	switch (BPF_CLASS(code)) {
	case BPF_ALU:   fputc(size_name(BPF_W), fp);
	case BPF_ALU64: fputc(size_name(BPF_DW), fp);
	}
}

static void offset_dump(int16_t off, FILE *fp)
{
	if (off < 0)
		fprintf(fp, "L%d", -off);
	else
		fprintf(fp, "+%d", off);
}

static void __insn_dump(const struct bpf_insn insn, uint16_t dst, uint16_t src,
			FILE *fp)
{
	const char *name;
	enum {
		OFF_NONE,
		OFF_DST,
		OFF_SRC,
		OFF_EXP,
	} off = OFF_NONE;

	switch (BPF_CLASS(insn.code)) {
	case BPF_LD:
	case BPF_LDX:
		off = OFF_SRC;
		fprintf(fp, "ld%c", size_name(insn.code));
		break;

	case BPF_ST:
	case BPF_STX:
		off = OFF_DST;
		fprintf(fp, "st%c", size_name(insn.code));
		break;

	case BPF_ALU:
	case BPF_ALU64:
		alu_dump(insn.code, fp);
		break;

	case BPF_JMP:
		off = OFF_EXP;

		switch (BPF_OP(insn.code)) {
		case BPF_EXIT:
			fputs("exit", fp);
			return;
		case BPF_CALL:
			fputs("call\t", fp);

			name = bpf_func_name(insn.imm);
			if (name)
				fputs(name, fp);
			else
				fprintf(fp, "%d", insn.imm);
			return;
		case BPF_JA:
			fputs("ja\t", fp);
			offset_dump(insn.off, fp);
			return;

		case BPF_JEQ:  fputs("jeq", fp); break;
		case BPF_JNE:  fputs("jne", fp); break;
		case BPF_JGT:  fputs("jgt", fp); break;
		case BPF_JGE:  fputs("jge", fp); break;
		case BPF_JSGE: fputs("jsge", fp); break;
		case BPF_JSGT: fputs("jsgt", fp); break;
		default:
			goto unknown;
		}
		break;

	default:
		goto unknown;
	}

	fputc('\t', fp);
	reg_dump(dst, off == OFF_DST ? insn.off : 0, fp);		
	fputs(", ", fp);

	if (BPF_CLASS(insn.code) == BPF_LDX || BPF_CLASS(insn.code) == BPF_STX)
		goto reg_src;

	switch (BPF_SRC(insn.code)) {
	case BPF_K:
		fprintf(fp, "#%s0x%x", insn.imm < 0 ? "-" : "",
			insn.imm < 0 ? -insn.imm : insn.imm);
		break;
	case BPF_X:
	reg_src:
		reg_dump(src, off == OFF_SRC ? insn.off : 0, fp);		
		break;
	}

	if (off == OFF_EXP) {
		fputs(", ", fp);
		offset_dump(insn.off, fp);
	}

	return;

unknown:
	fprintf(fp, "data\t0x%16.16" PRIx64 "\n", *((uint64_t *)&insn));	
}

void insn_dump(struct bpf_insn insn, FILE *fp)
{
	__insn_dump(insn, insn.dst_reg, insn.src_reg, fp);
}

void vinsn_dump(struct vinsn *vi, FILE *fp)
{
	switch (vi->vitype) {
	case VI_INSN:
		__insn_dump(vi->insn.bpf, vi->insn.dst, vi->insn.src, fp);
		return;
	case VI_LDMAP:
		fputs("ldmap\t", fp); reg_dump(vi->map.reg, 0, fp);
		fprintf(fp, ", %s", vi->map.sym->name);
		return;
	case VI_LABEL:
		offset_dump(vi->label, fp);
		fputc(':', fp);
		return;
	case VI_REG_GET:
	case VI_REG_PUT:
		fputs((vi->vitype == VI_REG_GET) ? "+ " : "- ", fp);
		reg_dump(vi->reg, 0, fp);
		return;
	}
}

void ir_dump(struct ir *ir, FILE *fp)
{
	size_t i;

	for (i = 0; i < ir->len; i++) {
		struct vinsn *vi = &ir->vi[i];

		switch (vi->vitype) {
		case VI_INSN:
		case VI_LDMAP:
			fputc('\t', fp);
			break;
		case VI_REG_GET:
		case VI_REG_PUT:
			fputs("\e[2m", fp);
		case VI_LABEL:
		default:
			break;
		}

		vinsn_dump(vi, fp);

		/* print multiple gets/puts on one line */
		switch (vi->vitype) {
		case VI_REG_GET:
			for (; (vi + 1)->vitype == VI_REG_GET; vi++, i++) {
				fputs(", ", fp);
				reg_dump((vi + 1)->reg, 0, fp);
			}
			fputs("\e[0m", fp);
			break;
		case VI_REG_PUT:
			for (; (vi + 1)->vitype == VI_REG_PUT; vi++, i++) {
				fputs(", ", fp);
				reg_dump((vi + 1)->reg, 0, fp);
			}
			fputs("\e[0m", fp);
			break;
		default:
			break;
		}

		fputc('\n', fp);
	}
}

static void ir_emit(struct ir *ir, struct vinsn *vi)
{
	ir->vi = realloc(ir->vi, (++ir->len)*sizeof(*vi));
	assert(ir->vi);

	ir->vi[ir->len - 1] = *vi;
}

void ir_emit_insn(struct ir *ir, struct bpf_insn bpf, uint16_t dst, uint16_t src)
{
	struct vinsn vi;

	vi.vitype = VI_INSN;
	vi.insn.bpf = bpf;
	vi.insn.dst = dst;
	vi.insn.src = src;
	ir_emit(ir, &vi);
}

void ir_emit_ldmap(struct ir *ir, uint16_t dst, struct sym *map)
{
	struct vinsn vi;

	vi.vitype = VI_LDMAP;
	vi.map.reg = dst;
	vi.map.sym = map;
	ir_emit(ir, &vi);
}

void ir_emit_label  (struct ir *ir, int16_t label)
{
	struct vinsn vi;

	vi.vitype = VI_LABEL;
	vi.label = label;
	ir_emit(ir, &vi);
}

/* void ir_emit_reg_get(struct ir *ir, uint16_t reg) */
/* { */
/* 	struct vinsn vi; */

/* 	vi.vitype = VI_REG_GET; */
/* 	vi.reg = reg; */
/* 	ir_emit(ir, &vi); */
/* } */

/* void ir_emit_reg_put(struct ir *ir, uint16_t reg) */
/* { */
/* 	struct vinsn vi; */

/* 	vi.vitype = VI_REG_PUT; */
/* 	vi.reg = reg; */
/* 	ir_emit(ir, &vi); */
/* } */

void ir_emit_sym_to_reg(struct ir *ir, uint16_t dst, struct sym *src)
{
	struct irstate *irs = &src->irs;

	switch (irs->loc) {
	case LOC_IMM:
		ir_emit_insn(ir, MOV_IMM(0, irs->imm), dst, 0);
		break;
	case LOC_REG:
		ir_emit_insn(ir, MOV(0, 0), dst, irs->reg);
		break;
	case LOC_STACK:
		switch (irs->size) {
		case 1:
			ir_emit_insn(ir, LDXB(0, irs->stack, 0),
				     dst, BPF_REG_BP);
			break;
		case 2:
			ir_emit_insn(ir, LDXH(0, irs->stack, 0),
				     dst, BPF_REG_BP);
			break;
		case 4:
			ir_emit_insn(ir, LDXW(0, irs->stack, 0),
				     dst, BPF_REG_BP);
			break;
		case 8:
			ir_emit_insn(ir, LDXDW(0, irs->stack, 0),
				     dst, BPF_REG_BP);
			break;
		default:
			assert(0);
		}
		break;
	default:
		assert(0);
	}
}

void ir_emit_reg_to_sym(struct ir *ir, struct sym *dst, uint16_t src)
{
	struct irstate *irs = &dst->irs;

	switch (irs->loc) {
	case LOC_REG:
		ir_emit_insn(ir, MOV(0, 0), irs->reg, src);
		break;
	case LOC_STACK:
		switch (irs->size) {
		case 1:
			ir_emit_insn(ir, STXB(0, irs->stack, 0),
				     BPF_REG_BP, src);
			break;
		case 2:
			ir_emit_insn(ir, STXH(0, irs->stack, 0),
				     BPF_REG_BP, src);
			break;
		case 4:
			ir_emit_insn(ir, STXW(0, irs->stack, 0),
				     BPF_REG_BP, src);
			break;
		case 8:
			ir_emit_insn(ir, STXDW(0, irs->stack, 0),
				     BPF_REG_BP, src);
			break;
		default:
			assert(0);
		}
		break;
	default:
		assert(0);
	}
}

/* void ir_emit_xfer(struct ir *ir,  */

int16_t ir_alloc_label (struct ir *ir)
{
	return ir->next_label--;
}

uint16_t ir_alloc_register(struct ir *ir)
{
	return ir->next_reg++;
}

ssize_t ir_alloc_stack(struct ir *ir, size_t size)
{
	ir->sp -= size;
	assert(ir->sp > INT32_MIN);

	return ir->sp;
}

void ir_init_sym(struct ir *ir, struct sym *sym)
{
	struct irstate *irs = &sym->irs;
	struct type *t = type_base(sym->type);

	if (irs->loc)
		return;

	irs->size = type_sizeof(t);

	if (irs->hint.stack)
		goto alloc_stack;

	switch (t->ttype) {
	case T_SCALAR:
	case T_POINTER:
		irs->loc = LOC_REG;
		irs->reg = ir_alloc_register(ir);
		return;

	default:
	alloc_stack:
		irs->loc = LOC_STACK;
		irs->stack = ir_alloc_stack(ir, irs->size);
	}
}

struct ir *ir_new(void)
{
	struct ir *ir;

	ir = calloc(1, sizeof(*ir));
	assert(ir);

	ir->next_reg = vreg_base;
	ir->next_label = -1;
	return ir;
}