rewrite const math expressions

kprobe.c

 			 node_string(reg),
 			 NULL);
 
+	new->type = n->type;
+	new->list->type = &t_void;
+	new->list->next->type = &t_pt_regs;
+	new->list->next->list->type = &t_void;
+	new->list->next->list->next->type = type_ptr_of(&t_pt_regs);
 	return node_replace(n, new);
 }
 

node.c

 		fputs(n->ident, fp);
 		break;
 	case N_NUM:
-		fprintf(fp, "%#"PRIx64, n->num);
+		fprintf(fp, "%"PRId64, n->num);
 		break;
 	case N_STRING:
 		fprintf(fp, "\"%s\"", n->string);

node.h

 typedef enum kwclass {
 	KW_SUBSCRIPT = '[',
 	KW_ASSIGN = '=',
-	KW_ARITH = 'a',
+	KW_BINOP = 'b',
 } kwclass_t;
 
 typedef enum kwarith {

ply.c

 					      node_list(node_ident("pid")),
 					      NULL),
 				   node_vlist(node_ident("quantize"),
-					      node_vlist(node_keyword('a', '-'),
+					      node_vlist(node_keyword('b', '-'),
 							 node_list(node_ident("time")),
 							 node_ident("t0"),
 							 NULL),
 
 		return sym_add(dst->sym->st, dst->ident, dst->type, NULL);
 
-	case KW_ARITH:
+	case KW_BINOP:
 		dst = node_next(n);
 		src = node_next(dst);
 		assert(dst && src);
 	return validate_func(n->list);
 }
 
+int rewrite_const_math(node_t *n)
+{
+	int64_t result;
+	node_t *a, *b, *new;
+	int op;
+
+	op = n->list->keyword.op;
+	a = node_next(n->list);
+	b = node_next(a);
+
+	switch (op) {
+	case '*': result = a->num *  b->num; break;
+	case '/': result = a->num /  b->num; break;
+	case '%': result = a->num %  b->num; break;
+	case '+': result = a->num +  b->num; break;
+	case '-': result = a->num -  b->num; break;
+	case '<': result = a->num << b->num; break;
+	case '>': result = a->num >> b->num; break;
+	default: return 0;
+	}
+
+	new = node_num(result);
+	new->type = n->type;
+	return node_replace(n, new);
+}
+
 int pass_rewrite_ast(node_t *n, void *_prog)
 {
 	prog_t *prog = _prog;
 			return err;
 	}
 
+	/* pre-compute binops where both sides are constants */
+	if ((n->ntype == N_LIST)
+	    && (n->list->ntype == N_KEYWORD)
+	    && (n->list->keyword.class == KW_BINOP)
+	    && (node_next(n->list)->ntype == N_NUM)
+	    && (node_next(node_next(n->list))->ntype == N_NUM))
+		return rewrite_const_math(n);
+
 	return 0;
 }