001: /* Copyright (C) 2004 - 2007 db4objects Inc. http://www.db4o.com
002:
003: This file is part of the db4o open source object database.
004:
005: db4o is free software; you can redistribute it and/or modify it under
006: the terms of version 2 of the GNU General Public License as published
007: by the Free Software Foundation and as clarified by db4objects' GPL
008: interpretation policy, available at
009: http://www.db4o.com/about/company/legalpolicies/gplinterpretation/
010: Alternatively you can write to db4objects, Inc., 1900 S Norfolk Street,
011: Suite 350, San Mateo, CA 94403, USA.
012:
013: db4o is distributed in the hope that it will be useful, but WITHOUT ANY
014: WARRANTY; without even the implied warranty of MERCHANTABILITY or
015: FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
016: for more details.
017:
018: You should have received a copy of the GNU General Public License along
019: with this program; if not, write to the Free Software Foundation, Inc.,
020: 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
021: package EDU.purdue.cs.bloat.tree;
022:
023: import java.util.*;
024:
025: /**
026: * Type1Visitor...
027: */
028: public class Type1Visitor extends AscendVisitor {
029:
030: Node turningPoint; /*
031: * where we were when we started descending the tree
032: * instead of ascending
033: */
034:
035: boolean found; /* have we found an earlier occurence */
036:
037: public Type1Visitor(final Hashtable defInfoMap,
038: final Hashtable useInfoMap) {
039: super (defInfoMap, useInfoMap);
040: }
041:
042: public void search(final LocalExpr start) {
043:
044: this .start = start;
045: previous = this .start;
046: found = false;
047: start.parent().visit(this );
048: if (!found) {
049:
050: if (turningPoint != null) {
051: (new Type1UpVisitor(defInfoMap, useInfoMap)).search(
052: turningPoint, start);
053: } else { // search failed (one place I saw this was in
054: // a ZeroCheckExpression)
055:
056: ((DefInformation) defInfoMap.get(start.def())).type1s += 3;
057: }
058:
059: }
060:
061: }
062:
063: public void check(final Node node) {
064:
065: if ((node instanceof Expr) && ((Expr) node).type().isWide()) {
066: turningPoint = null;
067: return; // give up. We cannot swap around a wide value.
068: }
069:
070: turningPoint = node;
071:
072: if (node instanceof StoreExpr) {
073: check(((StoreExpr) node).expr()); // to search down the expression
074: // being stored
075: } else if (!(node instanceof LocalExpr)
076: && (node instanceof Expr)) {
077: found = (new Type1DownVisitor(useInfoMap, defInfoMap))
078: .search(node, start);
079: }
080:
081: }
082: }
083:
084: class Type1UpVisitor extends AscendVisitor {
085:
086: Node turningPoint;
087:
088: boolean found;
089:
090: Type1UpVisitor(final Hashtable defInfoMap,
091: final Hashtable useInfoMap) {
092: super (defInfoMap, useInfoMap);
093: }
094:
095: public void search(final Node turningPoint, final LocalExpr start) {
096:
097: found = false;
098: this .start = start;
099: previous = turningPoint;
100: this .turningPoint = turningPoint;
101: if ((turningPoint.parent() != null)
102: && !(turningPoint.parent() instanceof Tree)) {
103: // go more than one statement earlier
104: // because we don't know if the intermediate
105: // statment leaves anything on the stack.
106: turningPoint.parent().visit(this );
107: }
108:
109: if (!found) {
110: // if we've found nothing by now, we won't find anything.
111: // setting the type1s of the definition to something 3 or
112: // greater insures the variable will be stored
113: ((DefInformation) defInfoMap.get(start.def())).type1s += 3;
114: }
115:
116: }
117:
118: public void check(final Node node) {
119:
120: if (node instanceof ExprStmt) {
121: check(((ExprStmt) node).expr()); // might be something we want
122: } else if (node instanceof StoreExpr) {
123: check(((StoreExpr) node).target()); // to see if the target matches
124: } else if ((node instanceof LocalExpr)
125: && ((((LocalExpr) node).index() == start.index() // compare
126: // index))
127: && (((LocalExpr) node).def() == start.def())))) { // and def
128: // we've found a match
129: // update information
130: ((UseInformation) useInfoMap.get(start)).type = 1;
131: ((UseInformation) useInfoMap.get(node)).type1s++;
132: ((DefInformation) defInfoMap.get(start.def())).type1s++;
133: found = true;
134: return;
135: }
136:
137: }
138:
139: }
140:
141: class Type1DownVisitor extends DescendVisitor {
142:
143: public Type1DownVisitor(final Hashtable useInfoMap,
144: final Hashtable defInfoMap) {
145: super (useInfoMap, defInfoMap);
146: }
147:
148: public void visitLocalExpr(final LocalExpr expr) {
149:
150: if ((expr.index() == start.index())
151: && (expr.def() == start.def())) {
152: // we've found a match
153: // update information
154: ((UseInformation) useInfoMap.get(start)).type = 1;
155: final UseInformation ui = (UseInformation) useInfoMap
156: .get(expr);
157: ui.type1s++;
158: if (exchangeFactor == 1) {
159: ui.type1_x1s++;
160: }
161: if (exchangeFactor == 2) {
162: ui.type1_x2s++;
163: }
164: // System.err.println(expr.toString());
165: ((DefInformation) defInfoMap.get(expr.def())).type1s++;
166: found = true;
167: }
168: }
169:
170: }
|