Move support/tools/* back into utils
llvm-svn: 8875
diff --git a/llvm/utils/Burg/table.c b/llvm/utils/Burg/table.c
new file mode 100644
index 0000000..1de74f9
--- /dev/null
+++ b/llvm/utils/Burg/table.c
@@ -0,0 +1,552 @@
+char rcsid_table[] = "$Id$";
+
+#include "b.h"
+#include <string.h>
+#include <stdio.h>
+
+static void growIndex_Map ARGS((Index_Map *));
+static Relevant newRelevant ARGS((void));
+static Dimension newDimension ARGS((Operator, int));
+static void GT_1 ARGS((Table));
+static void GT_2_0 ARGS((Table));
+static void GT_2_1 ARGS((Table));
+static void growTransition ARGS((Table, int));
+static Item_Set restrict ARGS((Dimension, Item_Set));
+static void addHP_1 ARGS((Table, Item_Set));
+static void addHP_2_0 ARGS((Table, Item_Set));
+static void addHP_2_1 ARGS((Table, Item_Set));
+static void addHyperPlane ARGS((Table, int, Item_Set));
+
+static void
+growIndex_Map(r) Index_Map *r;
+{
+ Index_Map new;
+
+ new.max_size = r->max_size + STATES_INCR;
+ new.class = (Item_Set*) zalloc(new.max_size * sizeof(Item_Set));
+ assert(new.class);
+ memcpy(new.class, r->class, r->max_size * sizeof(Item_Set));
+ zfree(r->class);
+ *r = new;
+}
+
+static Relevant
+newRelevant()
+{
+ Relevant r = (Relevant) zalloc(max_nonterminal * sizeof(*r));
+ return r;
+}
+
+void
+addRelevant(r, nt) Relevant r; NonTerminalNum nt;
+{
+ int i;
+
+ for (i = 0; r[i]; i++) {
+ if (r[i] == nt) {
+ break;
+ }
+ }
+ if (!r[i]) {
+ r[i] = nt;
+ }
+}
+
+static Dimension
+newDimension(op, index) Operator op; ArityNum index;
+{
+ Dimension d;
+ List pl;
+ Relevant r;
+
+ assert(op);
+ assert(index >= 0 && index < op->arity);
+ d = (Dimension) zalloc(sizeof(struct dimension));
+ assert(d);
+
+ r = d->relevant = newRelevant();
+ for (pl = rules; pl; pl = pl->next) {
+ Rule pr = (Rule) pl->x;
+ if (pr->pat->op == op) {
+ addRelevant(r, pr->pat->children[index]->num);
+ }
+ }
+
+ d->index_map.max_size = STATES_INCR;
+ d->index_map.class = (Item_Set*)
+ zalloc(d->index_map.max_size * sizeof(Item_Set));
+ d->map = newMapping(DIM_MAP_SIZE);
+ d->max_size = TABLE_INCR;
+
+ return d;
+}
+
+Table
+newTable(op) Operator op;
+{
+ Table t;
+ int i, size;
+
+ assert(op);
+
+ t = (Table) zalloc(sizeof(struct table));
+ assert(t);
+
+ t->op = op;
+
+ for (i = 0; i < op->arity; i++) {
+ t->dimen[i] = newDimension(op, i);
+ }
+
+ size = 1;
+ for (i = 0; i < op->arity; i++) {
+ size *= t->dimen[i]->max_size;
+ }
+ t->transition = (Item_Set*) zalloc(size * sizeof(Item_Set));
+ t->relevant = newRelevant();
+ assert(t->transition);
+
+ return t;
+}
+
+static void
+GT_1(t) Table t;
+{
+ Item_Set *ts;
+ ItemSetNum oldsize = t->dimen[0]->max_size;
+ ItemSetNum newsize = t->dimen[0]->max_size + TABLE_INCR;
+
+ t->dimen[0]->max_size = newsize;
+
+ ts = (Item_Set*) zalloc(newsize * sizeof(Item_Set));
+ assert(ts);
+ memcpy(ts, t->transition, oldsize * sizeof(Item_Set));
+ zfree(t->transition);
+ t->transition = ts;
+}
+
+static void
+GT_2_0(t) Table t;
+{
+ Item_Set *ts;
+ ItemSetNum oldsize = t->dimen[0]->max_size;
+ ItemSetNum newsize = t->dimen[0]->max_size + TABLE_INCR;
+ int size;
+
+ t->dimen[0]->max_size = newsize;
+
+ size = newsize * t->dimen[1]->max_size;
+
+ ts = (Item_Set*) zalloc(size * sizeof(Item_Set));
+ assert(ts);
+ memcpy(ts, t->transition, oldsize*t->dimen[1]->max_size * sizeof(Item_Set));
+ zfree(t->transition);
+ t->transition = ts;
+}
+
+static void
+GT_2_1(t) Table t;
+{
+ Item_Set *ts;
+ ItemSetNum oldsize = t->dimen[1]->max_size;
+ ItemSetNum newsize = t->dimen[1]->max_size + TABLE_INCR;
+ int size;
+ Item_Set *from;
+ Item_Set *to;
+ int i1, i2;
+
+ t->dimen[1]->max_size = newsize;
+
+ size = newsize * t->dimen[0]->max_size;
+
+ ts = (Item_Set*) zalloc(size * sizeof(Item_Set));
+ assert(ts);
+
+ from = t->transition;
+ to = ts;
+ for (i1 = 0; i1 < t->dimen[0]->max_size; i1++) {
+ for (i2 = 0; i2 < oldsize; i2++) {
+ to[i2] = from[i2];
+ }
+ to += newsize;
+ from += oldsize;
+ }
+ zfree(t->transition);
+ t->transition = ts;
+}
+
+static void
+growTransition(t, dim) Table t; ArityNum dim;
+{
+
+ assert(t);
+ assert(t->op);
+ assert(dim < t->op->arity);
+
+ switch (t->op->arity) {
+ default:
+ assert(0);
+ break;
+ case 1:
+ GT_1(t);
+ return;
+ case 2:
+ switch (dim) {
+ default:
+ assert(0);
+ break;
+ case 0:
+ GT_2_0(t);
+ return;
+ case 1:
+ GT_2_1(t);
+ return;
+ }
+ }
+}
+
+static Item_Set
+restrict(d, ts) Dimension d; Item_Set ts;
+{
+ DeltaCost base;
+ Item_Set r;
+ int found;
+ register Relevant r_ptr = d->relevant;
+ register Item *ts_current = ts->closed;
+ register Item *r_current;
+ register int i;
+ register int nt;
+
+ ZEROCOST(base);
+ found = 0;
+ r = newItem_Set(d->relevant);
+ r_current = r->virgin;
+ for (i = 0; (nt = r_ptr[i]) != 0; i++) {
+ if (ts_current[nt].rule) {
+ r_current[nt].rule = &stub_rule;
+ if (!found) {
+ found = 1;
+ ASSIGNCOST(base, ts_current[nt].delta);
+ } else {
+ if (LESSCOST(ts_current[nt].delta, base)) {
+ ASSIGNCOST(base, ts_current[nt].delta);
+ }
+ }
+ }
+ }
+
+ /* zero align */
+ for (i = 0; (nt = r_ptr[i]) != 0; i++) {
+ if (r_current[nt].rule) {
+ ASSIGNCOST(r_current[nt].delta, ts_current[nt].delta);
+ MINUSCOST(r_current[nt].delta, base);
+ }
+ }
+ assert(!r->closed);
+ r->representative = ts;
+ return r;
+}
+
+static void
+addHP_1(t, ts) Table t; Item_Set ts;
+{
+ List pl;
+ Item_Set e;
+ Item_Set tmp;
+ int new;
+
+ e = newItem_Set(t->relevant);
+ assert(e);
+ e->kids[0] = ts->representative;
+ for (pl = t->rules; pl; pl = pl->next) {
+ Rule p = (Rule) pl->x;
+ if (t->op == p->pat->op && ts->virgin[p->pat->children[0]->num].rule) {
+ DeltaCost dc;
+ ASSIGNCOST(dc, ts->virgin[p->pat->children[0]->num].delta);
+ ADDCOST(dc, p->delta);
+ if (!e->virgin[p->lhs->num].rule || LESSCOST(dc, e->virgin[p->lhs->num].delta)) {
+ e->virgin[p->lhs->num].rule = p;
+ ASSIGNCOST(e->virgin[p->lhs->num].delta, dc);
+ e->op = t->op;
+ }
+ }
+ }
+ trim(e);
+ zero(e);
+ tmp = encode(globalMap, e, &new);
+ assert(ts->num < t->dimen[0]->map->max_size);
+ t->transition[ts->num] = tmp;
+ if (new) {
+ closure(e);
+ addQ(globalQ, tmp);
+ } else {
+ freeItem_Set(e);
+ }
+}
+
+static void
+addHP_2_0(t, ts) Table t; Item_Set ts;
+{
+ List pl;
+ register Item_Set e;
+ Item_Set tmp;
+ int new;
+ int i2;
+
+ assert(t->dimen[1]->map->count <= t->dimen[1]->map->max_size);
+ for (i2 = 0; i2 < t->dimen[1]->map->count; i2++) {
+ e = newItem_Set(t->relevant);
+ assert(e);
+ e->kids[0] = ts->representative;
+ e->kids[1] = t->dimen[1]->map->set[i2]->representative;
+ for (pl = t->rules; pl; pl = pl->next) {
+ register Rule p = (Rule) pl->x;
+
+ if (t->op == p->pat->op
+ && ts->virgin[p->pat->children[0]->num].rule
+ && t->dimen[1]->map->set[i2]->virgin[p->pat->children[1]->num].rule){
+ DeltaCost dc;
+ ASSIGNCOST(dc, p->delta);
+ ADDCOST(dc, ts->virgin[p->pat->children[0]->num].delta);
+ ADDCOST(dc, t->dimen[1]->map->set[i2]->virgin[p->pat->children[1]->num].delta);
+
+ if (!e->virgin[p->lhs->num].rule || LESSCOST(dc, e->virgin[p->lhs->num].delta)) {
+ e->virgin[p->lhs->num].rule = p;
+ ASSIGNCOST(e->virgin[p->lhs->num].delta, dc);
+ e->op = t->op;
+ }
+ }
+ }
+ trim(e);
+ zero(e);
+ tmp = encode(globalMap, e, &new);
+ assert(ts->num < t->dimen[0]->map->max_size);
+ t->transition[ts->num * t->dimen[1]->max_size + i2] = tmp;
+ if (new) {
+ closure(e);
+ addQ(globalQ, tmp);
+ } else {
+ freeItem_Set(e);
+ }
+ }
+}
+
+static void
+addHP_2_1(t, ts) Table t; Item_Set ts;
+{
+ List pl;
+ register Item_Set e;
+ Item_Set tmp;
+ int new;
+ int i1;
+
+ assert(t->dimen[0]->map->count <= t->dimen[0]->map->max_size);
+ for (i1 = 0; i1 < t->dimen[0]->map->count; i1++) {
+ e = newItem_Set(t->relevant);
+ assert(e);
+ e->kids[0] = t->dimen[0]->map->set[i1]->representative;
+ e->kids[1] = ts->representative;
+ for (pl = t->rules; pl; pl = pl->next) {
+ register Rule p = (Rule) pl->x;
+
+ if (t->op == p->pat->op
+ && ts->virgin[p->pat->children[1]->num].rule
+ && t->dimen[0]->map->set[i1]->virgin[p->pat->children[0]->num].rule){
+ DeltaCost dc;
+ ASSIGNCOST(dc, p->delta );
+ ADDCOST(dc, ts->virgin[p->pat->children[1]->num].delta);
+ ADDCOST(dc, t->dimen[0]->map->set[i1]->virgin[p->pat->children[0]->num].delta);
+ if (!e->virgin[p->lhs->num].rule || LESSCOST(dc, e->virgin[p->lhs->num].delta)) {
+ e->virgin[p->lhs->num].rule = p;
+ ASSIGNCOST(e->virgin[p->lhs->num].delta, dc);
+ e->op = t->op;
+ }
+ }
+ }
+ trim(e);
+ zero(e);
+ tmp = encode(globalMap, e, &new);
+ assert(ts->num < t->dimen[1]->map->max_size);
+ t->transition[i1 * t->dimen[1]->max_size + ts->num] = tmp;
+ if (new) {
+ closure(e);
+ addQ(globalQ, tmp);
+ } else {
+ freeItem_Set(e);
+ }
+ }
+}
+
+static void
+addHyperPlane(t, i, ts) Table t; ArityNum i; Item_Set ts;
+{
+ switch (t->op->arity) {
+ default:
+ assert(0);
+ break;
+ case 1:
+ addHP_1(t, ts);
+ return;
+ case 2:
+ switch (i) {
+ default:
+ assert(0);
+ break;
+ case 0:
+ addHP_2_0(t, ts);
+ return;
+ case 1:
+ addHP_2_1(t, ts);
+ return;
+ }
+ }
+}
+
+void
+addToTable(t, ts) Table t; Item_Set ts;
+{
+ ArityNum i;
+
+ assert(t);
+ assert(ts);
+ assert(t->op);
+
+ for (i = 0; i < t->op->arity; i++) {
+ Item_Set r;
+ Item_Set tmp;
+ int new;
+
+ r = restrict(t->dimen[i], ts);
+ tmp = encode(t->dimen[i]->map, r, &new);
+ if (t->dimen[i]->index_map.max_size <= ts->num) {
+ growIndex_Map(&t->dimen[i]->index_map);
+ }
+ assert(ts->num < t->dimen[i]->index_map.max_size);
+ t->dimen[i]->index_map.class[ts->num] = tmp;
+ if (new) {
+ if (t->dimen[i]->max_size <= r->num) {
+ growTransition(t, i);
+ }
+ addHyperPlane(t, i, r);
+ } else {
+ freeItem_Set(r);
+ }
+ }
+}
+
+Item_Set *
+transLval(t, row, col) Table t; int row; int col;
+{
+ switch (t->op->arity) {
+ case 0:
+ assert(row == 0);
+ assert(col == 0);
+ return t->transition;
+ case 1:
+ assert(col == 0);
+ return t->transition + row;
+ case 2:
+ return t->transition + row * t->dimen[1]->max_size + col;
+ default:
+ assert(0);
+ }
+ return 0;
+}
+
+void
+dumpRelevant(r) Relevant r;
+{
+ for (; *r; r++) {
+ printf("%4d", *r);
+ }
+}
+
+void
+dumpIndex_Map(r) Index_Map *r;
+{
+ int i;
+
+ printf("BEGIN Index_Map: MaxSize (%d)\n", r->max_size);
+ for (i = 0; i < globalMap->count; i++) {
+ printf("\t#%d: -> %d\n", i, r->class[i]->num);
+ }
+ printf("END Index_Map:\n");
+}
+
+void
+dumpDimension(d) Dimension d;
+{
+ printf("BEGIN Dimension:\n");
+ printf("Relevant: ");
+ dumpRelevant(d->relevant);
+ printf("\n");
+ dumpIndex_Map(&d->index_map);
+ dumpMapping(d->map);
+ printf("MaxSize of dimension = %d\n", d->max_size);
+ printf("END Dimension\n");
+}
+
+void
+dumpTable(t, full) Table t; int full;
+{
+ int i;
+
+ if (!t) {
+ printf("NO Table yet.\n");
+ return;
+ }
+ printf("BEGIN Table:\n");
+ if (full) {
+ dumpOperator(t->op, 0);
+ }
+ for (i = 0; i < t->op->arity; i++) {
+ printf("BEGIN dimension(%d)\n", i);
+ dumpDimension(t->dimen[i]);
+ printf("END dimension(%d)\n", i);
+ }
+ dumpTransition(t);
+ printf("END Table:\n");
+}
+
+void
+dumpTransition(t) Table t;
+{
+ int i,j;
+
+ switch (t->op->arity) {
+ case 0:
+ printf("{ %d }", t->transition[0]->num);
+ break;
+ case 1:
+ printf("{");
+ for (i = 0; i < t->dimen[0]->map->count; i++) {
+ if (i > 0) {
+ printf(",");
+ }
+ printf("%5d", t->transition[i]->num);
+ }
+ printf("}");
+ break;
+ case 2:
+ printf("{");
+ for (i = 0; i < t->dimen[0]->map->count; i++) {
+ if (i > 0) {
+ printf(",");
+ }
+ printf("\n");
+ printf("{");
+ for (j = 0; j < t->dimen[1]->map->count; j++) {
+ Item_Set *ts = transLval(t, i, j);
+ if (j > 0) {
+ printf(",");
+ }
+ printf("%5d", (*ts)->num);
+ }
+ printf("}");
+ }
+ printf("\n}\n");
+ break;
+ default:
+ assert(0);
+ }
+}