1 files changed, 363 insertions, 363 deletions

diff --git a/llvm/utils/Burg/trim.c b/llvm/utils/Burg/trim.c
index 05ee2d0f646..83d3fad42ff 100644
--- a/llvm/utils/Burg/trim.c
+++ b/llvm/utils/Burg/trim.c
@@ -16,397 +16,397 @@ static Relation *newAllPairs ARGS((void));
 static void
 siblings(i, j) int i; int j;
 {
-	int k;
-	List pl;
-	DeltaCost Max;
-	int foundmax;
-
-	allpairs[i][j].sibComputed = 1;
-
-	if (i == 1) {
-		return; /* never trim start symbol */
-	}
-	if (i==j) {
-		return;
-	}
-
-	ZEROCOST(Max);
-	foundmax = 0;
-
-	for (k = 1; k < max_nonterminal; k++) {
-		DeltaCost tmp;
-
-		if (k==i || k==j) {
-			continue;
-		}
-		if (!allpairs[k][i].rule) {
-			continue;
-		}
-		if (!allpairs[k][j].rule) {
-			return;
-		}
-		ASSIGNCOST(tmp, allpairs[k][j].chain);
-		MINUSCOST(tmp, allpairs[k][i].chain);
-		if (foundmax) {
-			if (LESSCOST(Max, tmp)) {
-				ASSIGNCOST(Max, tmp);
-			}
-		} else {
-			foundmax = 1;
-			ASSIGNCOST(Max, tmp);
-		}
-	}
-
-	for (pl = rules; pl; pl = pl->next) {
-		Rule p = (Rule) pl->x;
-		Operator op = p->pat->op;
-		List oprule;
-		DeltaCost Min;
-		int foundmin;
-		
-		if (!op) {
-			continue;
-		}
-		switch (op->arity) {
-		case 0:
-			continue;
-		case 1:
-			if (!allpairs[p->pat->children[0]->num ][ i].rule) {
-				continue;
-			}
-			foundmin = 0;
-			for (oprule = op->table->rules; oprule; oprule = oprule->next) {
-				Rule s = (Rule) oprule->x;
-				DeltaPtr Cx;
-				DeltaPtr Csj;
-				DeltaPtr Cpi;
-				DeltaCost tmp;
-
-				if (!allpairs[p->lhs->num ][ s->lhs->num].rule
-				 || !allpairs[s->pat->children[0]->num ][ j].rule) {
-					continue;
-				}
-				Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
-				Csj= allpairs[s->pat->children[0]->num ][ j].chain;
-				Cpi= allpairs[p->pat->children[0]->num ][ i].chain;
-				ASSIGNCOST(tmp, Cx);
-				ADDCOST(tmp, s->delta);
-				ADDCOST(tmp, Csj);
-				MINUSCOST(tmp, Cpi);
-				MINUSCOST(tmp, p->delta);
-				if (foundmin) {
-					if (LESSCOST(tmp, Min)) {
-						ASSIGNCOST(Min, tmp);
-					}
-				} else {
-					foundmin = 1;
-					ASSIGNCOST(Min, tmp);
-				}
-			}
-			if (!foundmin) {
-				return;
-			}
-			if (foundmax) {
-				if (LESSCOST(Max, Min)) {
-					ASSIGNCOST(Max, Min);
-				}
-			} else {
-				foundmax = 1;
-				ASSIGNCOST(Max, Min);
-			}
-			break;
-		case 2:
-		/* do first dimension */
-		if (allpairs[p->pat->children[0]->num ][ i].rule) {
-			foundmin = 0;
-			for (oprule = op->table->rules; oprule; oprule = oprule->next) {
-				Rule s = (Rule) oprule->x;
-				DeltaPtr Cx;
-				DeltaPtr Cb;
-				DeltaPtr Csj;
-				DeltaPtr Cpi;
-				DeltaCost tmp;
-
-				if (allpairs[p->lhs->num ][ s->lhs->num].rule
-				 && allpairs[s->pat->children[0]->num ][ j].rule
-				 && allpairs[s->pat->children[1]->num ][ p->pat->children[1]->num].rule) {
-					Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
-					Csj= allpairs[s->pat->children[0]->num ][ j].chain;
-					Cpi= allpairs[p->pat->children[0]->num ][ i].chain;
-					Cb = allpairs[s->pat->children[1]->num ][ p->pat->children[1]->num].chain;
-					ASSIGNCOST(tmp, Cx);
-					ADDCOST(tmp, s->delta);
-					ADDCOST(tmp, Csj);
-					ADDCOST(tmp, Cb);
-					MINUSCOST(tmp, Cpi);
-					MINUSCOST(tmp, p->delta);
-					if (foundmin) {
-						if (LESSCOST(tmp, Min)) {
-							ASSIGNCOST(Min, tmp);
-						}
-					} else {
-						foundmin = 1;
-						ASSIGNCOST(Min, tmp);
-					}
-				}
-			}
-			if (!foundmin) {
-				return;
-			}
-			if (foundmax) {
-				if (LESSCOST(Max, Min)) {
-					ASSIGNCOST(Max, Min);
-				}
-			} else {
-				foundmax = 1;
-				ASSIGNCOST(Max, Min);
-			}
-		}
-		/* do second dimension */
-		if (allpairs[p->pat->children[1]->num ][ i].rule) {
-			foundmin = 0;
-			for (oprule = op->table->rules; oprule; oprule = oprule->next) {
-				Rule s = (Rule) oprule->x;
-				DeltaPtr Cx;
-				DeltaPtr Cb;
-				DeltaPtr Csj;
-				DeltaPtr Cpi;
-				DeltaCost tmp;
-
-				if (allpairs[p->lhs->num ][ s->lhs->num].rule
-				 && allpairs[s->pat->children[1]->num ][ j].rule
-				 && allpairs[s->pat->children[0]->num ][ p->pat->children[0]->num].rule) {
-					Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
-					Csj= allpairs[s->pat->children[1]->num ][ j].chain;
-					Cpi= allpairs[p->pat->children[1]->num ][ i].chain;
-					Cb = allpairs[s->pat->children[0]->num ][ p->pat->children[0]->num].chain;
-					ASSIGNCOST(tmp, Cx);
-					ADDCOST(tmp, s->delta);
-					ADDCOST(tmp, Csj);
-					ADDCOST(tmp, Cb);
-					MINUSCOST(tmp, Cpi);
-					MINUSCOST(tmp, p->delta);
-					if (foundmin) {
-						if (LESSCOST(tmp, Min)) {
-							ASSIGNCOST(Min, tmp);
-						}
-					} else {
-						foundmin = 1;
-						ASSIGNCOST(Min, tmp);
-					}
-				}
-			}
-			if (!foundmin) {
-				return;
-			}
-			if (foundmax) {
-				if (LESSCOST(Max, Min)) {
-					ASSIGNCOST(Max, Min);
-				}
-			} else {
-				foundmax = 1;
-				ASSIGNCOST(Max, Min);
-			}
-		}
-		break;
-		default:
-			assert(0);
-		}
-	}
-	allpairs[i ][ j].sibFlag = foundmax;
-	ASSIGNCOST(allpairs[i ][ j].sibling, Max);
+  int k;
+  List pl;
+  DeltaCost Max;
+  int foundmax;
+
+  allpairs[i][j].sibComputed = 1;
+
+  if (i == 1) {
+    return; /* never trim start symbol */
+  }
+  if (i==j) {
+    return;
+  }
+
+  ZEROCOST(Max);
+  foundmax = 0;
+
+  for (k = 1; k < max_nonterminal; k++) {
+    DeltaCost tmp;
+
+    if (k==i || k==j) {
+      continue;
+    }
+    if (!allpairs[k][i].rule) {
+      continue;
+    }
+    if (!allpairs[k][j].rule) {
+      return;
+    }
+    ASSIGNCOST(tmp, allpairs[k][j].chain);
+    MINUSCOST(tmp, allpairs[k][i].chain);
+    if (foundmax) {
+      if (LESSCOST(Max, tmp)) {
+        ASSIGNCOST(Max, tmp);
+      }
+    } else {
+      foundmax = 1;
+      ASSIGNCOST(Max, tmp);
+    }
+  }
+
+  for (pl = rules; pl; pl = pl->next) {
+    Rule p = (Rule) pl->x;
+    Operator op = p->pat->op;
+    List oprule;
+    DeltaCost Min;
+    int foundmin;
+
+    if (!op) {
+      continue;
+    }
+    switch (op->arity) {
+    case 0:
+      continue;
+    case 1:
+      if (!allpairs[p->pat->children[0]->num ][ i].rule) {
+        continue;
+      }
+      foundmin = 0;
+      for (oprule = op->table->rules; oprule; oprule = oprule->next) {
+        Rule s = (Rule) oprule->x;
+        DeltaPtr Cx;
+        DeltaPtr Csj;
+        DeltaPtr Cpi;
+        DeltaCost tmp;
+
+        if (!allpairs[p->lhs->num ][ s->lhs->num].rule
+         || !allpairs[s->pat->children[0]->num ][ j].rule) {
+          continue;
+        }
+        Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
+        Csj= allpairs[s->pat->children[0]->num ][ j].chain;
+        Cpi= allpairs[p->pat->children[0]->num ][ i].chain;
+        ASSIGNCOST(tmp, Cx);
+        ADDCOST(tmp, s->delta);
+        ADDCOST(tmp, Csj);
+        MINUSCOST(tmp, Cpi);
+        MINUSCOST(tmp, p->delta);
+        if (foundmin) {
+          if (LESSCOST(tmp, Min)) {
+            ASSIGNCOST(Min, tmp);
+          }
+        } else {
+          foundmin = 1;
+          ASSIGNCOST(Min, tmp);
+        }
+      }
+      if (!foundmin) {
+        return;
+      }
+      if (foundmax) {
+        if (LESSCOST(Max, Min)) {
+          ASSIGNCOST(Max, Min);
+        }
+      } else {
+        foundmax = 1;
+        ASSIGNCOST(Max, Min);
+      }
+      break;
+    case 2:
+    /* do first dimension */
+    if (allpairs[p->pat->children[0]->num ][ i].rule) {
+      foundmin = 0;
+      for (oprule = op->table->rules; oprule; oprule = oprule->next) {
+        Rule s = (Rule) oprule->x;
+        DeltaPtr Cx;
+        DeltaPtr Cb;
+        DeltaPtr Csj;
+        DeltaPtr Cpi;
+        DeltaCost tmp;
+
+        if (allpairs[p->lhs->num ][ s->lhs->num].rule
+         && allpairs[s->pat->children[0]->num ][ j].rule
+         && allpairs[s->pat->children[1]->num ][ p->pat->children[1]->num].rule) {
+          Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
+          Csj= allpairs[s->pat->children[0]->num ][ j].chain;
+          Cpi= allpairs[p->pat->children[0]->num ][ i].chain;
+          Cb = allpairs[s->pat->children[1]->num ][ p->pat->children[1]->num].chain;
+          ASSIGNCOST(tmp, Cx);
+          ADDCOST(tmp, s->delta);
+          ADDCOST(tmp, Csj);
+          ADDCOST(tmp, Cb);
+          MINUSCOST(tmp, Cpi);
+          MINUSCOST(tmp, p->delta);
+          if (foundmin) {
+            if (LESSCOST(tmp, Min)) {
+              ASSIGNCOST(Min, tmp);
+            }
+          } else {
+            foundmin = 1;
+            ASSIGNCOST(Min, tmp);
+          }
+        }
+      }
+      if (!foundmin) {
+        return;
+      }
+      if (foundmax) {
+        if (LESSCOST(Max, Min)) {
+          ASSIGNCOST(Max, Min);
+        }
+      } else {
+        foundmax = 1;
+        ASSIGNCOST(Max, Min);
+      }
+    }
+    /* do second dimension */
+    if (allpairs[p->pat->children[1]->num ][ i].rule) {
+      foundmin = 0;
+      for (oprule = op->table->rules; oprule; oprule = oprule->next) {
+        Rule s = (Rule) oprule->x;
+        DeltaPtr Cx;
+        DeltaPtr Cb;
+        DeltaPtr Csj;
+        DeltaPtr Cpi;
+        DeltaCost tmp;
+
+        if (allpairs[p->lhs->num ][ s->lhs->num].rule
+         && allpairs[s->pat->children[1]->num ][ j].rule
+         && allpairs[s->pat->children[0]->num ][ p->pat->children[0]->num].rule) {
+          Cx = allpairs[p->lhs->num ][ s->lhs->num].chain;
+          Csj= allpairs[s->pat->children[1]->num ][ j].chain;
+          Cpi= allpairs[p->pat->children[1]->num ][ i].chain;
+          Cb = allpairs[s->pat->children[0]->num ][ p->pat->children[0]->num].chain;
+          ASSIGNCOST(tmp, Cx);
+          ADDCOST(tmp, s->delta);
+          ADDCOST(tmp, Csj);
+          ADDCOST(tmp, Cb);
+          MINUSCOST(tmp, Cpi);
+          MINUSCOST(tmp, p->delta);
+          if (foundmin) {
+            if (LESSCOST(tmp, Min)) {
+              ASSIGNCOST(Min, tmp);
+            }
+          } else {
+            foundmin = 1;
+            ASSIGNCOST(Min, tmp);
+          }
+        }
+      }
+      if (!foundmin) {
+        return;
+      }
+      if (foundmax) {
+        if (LESSCOST(Max, Min)) {
+          ASSIGNCOST(Max, Min);
+        }
+      } else {
+        foundmax = 1;
+        ASSIGNCOST(Max, Min);
+      }
+    }
+    break;
+    default:
+      assert(0);
+    }
+  }
+  allpairs[i ][ j].sibFlag = foundmax;
+  ASSIGNCOST(allpairs[i ][ j].sibling, Max);
 }
 
 static void
 findAllNexts()
 {
-	int i,j;
-	int last;
-
-	for (i = 1; i < max_nonterminal; i++) {
-		last = 0;
-		for (j = 1; j < max_nonterminal; j++) {
-			if (allpairs[i ][j].rule) {
-				allpairs[i ][ last].nextchain = j;
-				last = j;
-			}
-		}
-	}
-	/*
-	for (i = 1; i < max_nonterminal; i++) {
-		last = 0;
-		for (j = 1; j < max_nonterminal; j++) {
-			if (allpairs[i ][j].sibFlag) {
-				allpairs[i ][ last].nextsibling = j;
-				last = j;
-			}
-		}
-	}
-	*/
+  int i,j;
+  int last;
+
+  for (i = 1; i < max_nonterminal; i++) {
+    last = 0;
+    for (j = 1; j < max_nonterminal; j++) {
+      if (allpairs[i ][j].rule) {
+        allpairs[i ][ last].nextchain = j;
+        last = j;
+      }
+    }
+  }
+  /*
+  for (i = 1; i < max_nonterminal; i++) {
+    last = 0;
+    for (j = 1; j < max_nonterminal; j++) {
+      if (allpairs[i ][j].sibFlag) {
+        allpairs[i ][ last].nextsibling = j;
+        last = j;
+      }
+    }
+  }
+  */
 }
 
 static Relation *
 newAllPairs()
 {
-	int i;
-	Relation *rv;
-
-	rv = (Relation*) zalloc(max_nonterminal * sizeof(Relation));
-	for (i = 0; i < max_nonterminal; i++) {
-		rv[i] = (Relation) zalloc(max_nonterminal * sizeof(struct relation));
-	}
-	return rv;
+  int i;
+  Relation *rv;
+
+  rv = (Relation*) zalloc(max_nonterminal * sizeof(Relation));
+  for (i = 0; i < max_nonterminal; i++) {
+    rv[i] = (Relation) zalloc(max_nonterminal * sizeof(struct relation));
+  }
+  return rv;
 }
 
 void
 findAllPairs()
 {
-	List pl;
-	int changes;
-	int j;
-
-	allpairs = newAllPairs();
-	for (pl = chainrules; pl; pl = pl->next) {
-		Rule p = (Rule) pl->x;
-		NonTerminalNum rhs = p->pat->children[0]->num;
-		NonTerminalNum lhs = p->lhs->num;
-		Relation r = &allpairs[lhs ][ rhs];
-
-		if (LESSCOST(p->delta, r->chain)) {
-			ASSIGNCOST(r->chain, p->delta);
-			r->rule = p;
-		}
-	}
-	for (j = 1; j < max_nonterminal; j++) {
-		Relation r = &allpairs[j ][ j];
-		ZEROCOST(r->chain);
-		r->rule = &stub_rule;
-	}
-	changes = 1;
-	while (changes) {
-		changes = 0;
-		for (pl = chainrules; pl; pl = pl->next) {
-			Rule p = (Rule) pl->x;
-			NonTerminalNum rhs = p->pat->children[0]->num;
-			NonTerminalNum lhs = p->lhs->num;
-			int i;
-
-			for (i = 1; i < max_nonterminal; i++) {
-				Relation r = &allpairs[rhs ][ i];
-				Relation s = &allpairs[lhs ][ i];
-				DeltaCost dc;
-				if (!r->rule) {
-					continue;
-				}
-				ASSIGNCOST(dc, p->delta);
-				ADDCOST(dc, r->chain);
-				if (!s->rule || LESSCOST(dc, s->chain)) {
-					s->rule = p;
-					ASSIGNCOST(s->chain, dc);
-					changes = 1;
-				}
-			}
-		}
-	}
-	findAllNexts();
+  List pl;
+  int changes;
+  int j;
+
+  allpairs = newAllPairs();
+  for (pl = chainrules; pl; pl = pl->next) {
+    Rule p = (Rule) pl->x;
+    NonTerminalNum rhs = p->pat->children[0]->num;
+    NonTerminalNum lhs = p->lhs->num;
+    Relation r = &allpairs[lhs ][ rhs];
+
+    if (LESSCOST(p->delta, r->chain)) {
+      ASSIGNCOST(r->chain, p->delta);
+      r->rule = p;
+    }
+  }
+  for (j = 1; j < max_nonterminal; j++) {
+    Relation r = &allpairs[j ][ j];
+    ZEROCOST(r->chain);
+    r->rule = &stub_rule;
+  }
+  changes = 1;
+  while (changes) {
+    changes = 0;
+    for (pl = chainrules; pl; pl = pl->next) {
+      Rule p = (Rule) pl->x;
+      NonTerminalNum rhs = p->pat->children[0]->num;
+      NonTerminalNum lhs = p->lhs->num;
+      int i;
+
+      for (i = 1; i < max_nonterminal; i++) {
+        Relation r = &allpairs[rhs ][ i];
+        Relation s = &allpairs[lhs ][ i];
+        DeltaCost dc;
+        if (!r->rule) {
+          continue;
+        }
+        ASSIGNCOST(dc, p->delta);
+        ADDCOST(dc, r->chain);
+        if (!s->rule || LESSCOST(dc, s->chain)) {
+          s->rule = p;
+          ASSIGNCOST(s->chain, dc);
+          changes = 1;
+        }
+      }
+    }
+  }
+  findAllNexts();
 }
 
 void
 trim(t) Item_Set t;
 {
-	int m,n;
-	static short *vec = 0;
-	int last;
-
-	assert(!t->closed);
-	debug(debugTrim, printf("Begin Trim\n"));
-	debug(debugTrim, dumpItem_Set(t));
-
-	last = 0;
-	if (!vec) {
-		vec = (short*) zalloc(max_nonterminal * sizeof(*vec));
-	}
-	for (m = 1; m < max_nonterminal; m++) {
-		if (t->virgin[m].rule) {
-			vec[last++] = m;
-		}
-	}
-	for (m = 0; m < last; m++) {
-		DeltaCost tmp;
-		int j;
-		int i;
-
-		i = vec[m];
-
-		for (j = allpairs[i ][ 0].nextchain; j; j = allpairs[i ][ j].nextchain) {
-
-			if (i == j) {
-				continue;
-			}
-			if (!t->virgin[j].rule) {
-				continue;
-			}
-			ASSIGNCOST(tmp, t->virgin[j].delta);
-			ADDCOST(tmp, allpairs[i ][ j].chain);
-			if (!LESSCOST(t->virgin[i].delta, tmp)) {
-				t->virgin[i].rule = 0;
-				ZEROCOST(t->virgin[i].delta);
-				debug(debugTrim, printf("Trimmed Chain (%d,%d)\n", i,j));
-				goto outer;
-			}
-			
-		}
-		if (!trimflag) {
-			continue;
-		}
-		for (n = 0; n < last; n++) {
-			j = vec[n];
-			if (i == j) {
-				continue;
-			}
-
-			if (!t->virgin[j].rule) {
-				continue;
-			}
-
-			if (!allpairs[i][j].sibComputed) {
-				siblings(i,j);
-			}
-			if (!allpairs[i][j].sibFlag) {
-				continue;
-			}
-			ASSIGNCOST(tmp, t->virgin[j].delta);
-			ADDCOST(tmp, allpairs[i ][ j].sibling);
-			if (!LESSCOST(t->virgin[i].delta, tmp)) {
-				t->virgin[i].rule = 0;
-				ZEROCOST(t->virgin[i].delta);
-				goto outer;
-			}
-		}
-
-		outer: ;
-	}
-
-	debug(debugTrim, dumpItem_Set(t));
-	debug(debugTrim, printf("End Trim\n"));
+  int m,n;
+  static short *vec = 0;
+  int last;
+
+  assert(!t->closed);
+  debug(debugTrim, printf("Begin Trim\n"));
+  debug(debugTrim, dumpItem_Set(t));
+
+  last = 0;
+  if (!vec) {
+    vec = (short*) zalloc(max_nonterminal * sizeof(*vec));
+  }
+  for (m = 1; m < max_nonterminal; m++) {
+    if (t->virgin[m].rule) {
+      vec[last++] = m;
+    }
+  }
+  for (m = 0; m < last; m++) {
+    DeltaCost tmp;
+    int j;
+    int i;
+
+    i = vec[m];
+
+    for (j = allpairs[i ][ 0].nextchain; j; j = allpairs[i ][ j].nextchain) {
+
+      if (i == j) {
+        continue;
+      }
+      if (!t->virgin[j].rule) {
+        continue;
+      }
+      ASSIGNCOST(tmp, t->virgin[j].delta);
+      ADDCOST(tmp, allpairs[i ][ j].chain);
+      if (!LESSCOST(t->virgin[i].delta, tmp)) {
+        t->virgin[i].rule = 0;
+        ZEROCOST(t->virgin[i].delta);
+        debug(debugTrim, printf("Trimmed Chain (%d,%d)\n", i,j));
+        goto outer;
+      }
+
+    }
+    if (!trimflag) {
+      continue;
+    }
+    for (n = 0; n < last; n++) {
+      j = vec[n];
+      if (i == j) {
+        continue;
+      }
+
+      if (!t->virgin[j].rule) {
+        continue;
+      }
+
+      if (!allpairs[i][j].sibComputed) {
+        siblings(i,j);
+      }
+      if (!allpairs[i][j].sibFlag) {
+        continue;
+      }
+      ASSIGNCOST(tmp, t->virgin[j].delta);
+      ADDCOST(tmp, allpairs[i ][ j].sibling);
+      if (!LESSCOST(t->virgin[i].delta, tmp)) {
+        t->virgin[i].rule = 0;
+        ZEROCOST(t->virgin[i].delta);
+        goto outer;
+      }
+    }
+
+    outer: ;
+  }
+
+  debug(debugTrim, dumpItem_Set(t));
+  debug(debugTrim, printf("End Trim\n"));
 }
 
 void
 dumpRelation(r) Relation r;
 {
-	printf("{ %d %ld %d %ld }", r->rule->erulenum, (long) r->chain, r->sibFlag, (long) r->sibling);
+  printf("{ %d %ld %d %ld }", r->rule->erulenum, (long) r->chain, r->sibFlag, (long) r->sibling);
 }
 
 void
 dumpAllPairs()
 {
-	int i,j;
-
-	printf("Dumping AllPairs\n");
-	for (i = 1; i < max_nonterminal; i++) {
-		for (j = 1; j < max_nonterminal; j++) {
-			dumpRelation(&allpairs[i ][j]);
-		}
-		printf("\n");
-	}
+  int i,j;
+
+  printf("Dumping AllPairs\n");
+  for (i = 1; i < max_nonterminal; i++) {
+    for (j = 1; j < max_nonterminal; j++) {
+      dumpRelation(&allpairs[i ][j]);
+    }
+    printf("\n");
+  }
 }