Ejemplo n.º 1
0
 /* hard part: the numbering */
 private void number(HCode hc, boolean callSites) {
   if (hc != null)
     for (Iterator it = hc.getElementsI(); it.hasNext(); ) {
       Quad q = (Quad) it.next();
       if ((q instanceof ANEW) || (q instanceof NEW)) alloc2int.put(q, new Integer(alloc_count++));
       else if (callSites && (q instanceof CALL)) call2int.put(q, new Integer(call_count++));
     }
 }
 /** Find fields which are *not* subclass-final. */
 private Set findBadFields(HCodeFactory hcf, ClassHierarchy ch) {
   Set badFields = new HashSet();
   // for each callable method...
   for (Iterator it = ch.callableMethods().iterator(); it.hasNext(); ) {
     HMethod hm = (HMethod) it.next();
     HCode hc = hcf.convert(hm);
     if (hc == null) continue; // xxx: native methods may write fields!
     // construct a must-param oracle for constructors.
     MustParamOracle mpo = isConstructor(hm) ? new MustParamOracle(hc) : null;
     // examine this method for writes
     HClass thisClass = hc.getMethod().getDeclaringClass();
     for (Iterator it2 = hc.getElementsI(); it2.hasNext(); ) {
       Quad q = (Quad) it2.next();
       if (q instanceof SET) {
         SET qq = (SET) q;
         // ignore writes of static fields.
         if (qq.isStatic()) continue;
         // if this is a constructor, than it may write only
         // to fields of 'this'
         if (isConstructor(hm)
             && mpo.isMustParam(qq.objectref())
             && mpo.whichMustParam(qq.objectref()) == 0) continue; // this is a permitted write.
         // writes by subclass methods to superclass fields are
         // okay. (but not writes by 'this' methods to 'this'
         // fields, unless the method is a constructor)
         if (qq.field().getDeclaringClass().isInstanceOf(thisClass)
             &&
             // XXX i think the presence of the 'isConstructor'
             // clause here is a bug. constructor writes
             // should be taken care of by clause above.
             (isConstructor(hm) || !thisClass.equals(qq.field().getDeclaringClass())))
           continue; // subclass writes are permitted.
         // non-permitted write!
         badFields.add(qq.field());
       }
     }
     // on to the next!
   }
   // done!  we have set of all bad (not subclass-final) fields.
   return Collections.unmodifiableSet(badFields);
 }
 /** returns a map from hfields to classification objects */
 private Map doOne(HCode hc) {
   Map map = mf.makeMap();
   HMethod hm = hc.getMethod();
   assert isConstructor(hm);
   HClass thisClass = hm.getDeclaringClass();
   // first, get a SimpleConstMap
   ConstMap cm = new SimpleConstMap(hc);
   // also create a MustParamOracle
   MustParamOracle mpo = new MustParamOracle(hc);
   // look at every SET and CALL.
   for (Iterator it = hc.getElementsI(); it.hasNext(); ) {
     Quad q = (Quad) it.next();
     if (q instanceof SET) {
       SET qq = (SET) q;
       // field set.
       if (qq.field().getDeclaringClass().equals(thisClass)) {
         Classification oc = (Classification) map.get(qq.field());
         // okay, is the value we're setting a constant? or param?
         Classification nc = makeClassification(cm, mpo, qq, qq.src());
         // XXX: CAN MERGE const with param if the const is
         // the 'right' value (the one we're optimizing for)
         if (oc != null) // null means we haven't seen this field yet.
         nc.merge(oc);
         map.put(qq.field(), nc);
       }
     }
     if (q instanceof CALL) {
       // deal with call to 'this' constructor.
       CALL qq = (CALL) q;
       if (isThisConstructor(qq.method(), qq)) {
         // recursively invoke!
         Map m = classifyMethod(qq.method()); // this should cache.
         // construct parameter mapping.
         Classification pc[] = new Classification[qq.paramsLength()];
         for (int i = 0; i < pc.length; i++) pc[i] = makeClassification(cm, mpo, qq, qq.params(i));
         // filter method's classifications through the mapping and
         // merge with our previous classifications.
         for (Iterator it2 = m.entrySet().iterator(); it2.hasNext(); ) {
           Map.Entry me = (Map.Entry) it2.next();
           HField hf = (HField) me.getKey();
           Classification oc = (Classification) map.get(hf);
           Classification nc = (Classification) me.getValue();
           // clone nc so we don't modify value in 'm'!
           nc = (Classification) nc.clone();
           // map method's params to this' params.
           nc.map(pc);
           if (oc != null) nc.merge(oc); // merge if necessary.
           map.put(hf, nc);
         }
       }
     }
   }
   // collect statistics.
   if (STATISTICS) {
     boolean has_const = false, has_param = false;
     for (Iterator it = map.values().iterator(); it.hasNext(); ) {
       Classification c = (Classification) it.next();
       if (c.param != -1) has_param = true;
       if (c.isConstant) has_const = true;
     }
     if (has_param) one_param_field++;
     if (has_const) one_const_field++;
     one_constructor++;
   }
   // okay, we're done!
   return Collections.unmodifiableMap(map);
 }