Beispiel #1
0
  public static void premain(String args, Instrumentation inst) throws Exception {
    try {
      String[] agentArgs;
      if (args == null) agentArgs = new String[] {""};
      else agentArgs = args.split(",");
      if (!agentArgs[0].equals("instrumenting")) jarFileName = agentArgs[0];
      BaseClassTransformer rct = null;
      rct = new BaseClassTransformer();
      if (agentArgs[0].equals("instrumenting")) {
        initVMClasses = new HashSet<String>();
        for (Class<?> c : inst.getAllLoadedClasses()) {
          ((Set<String>) initVMClasses).add(c.getName());
        }
      }
      if (!agentArgs[0].equals("instrumenting")) {

        inst.addTransformer(rct);
        Tracer.setLocals(new CounterThreadLocal());
        Tracer.overrideAll(true);
        for (Class<?> c : inst.getAllLoadedClasses()) {
          try {
            if (c.isInterface()) continue;
            if (c.isArray()) continue;
            byte[] bytes = rct.getBytes(c.getName());
            if (bytes == null) {
              continue;
            }
            inst.redefineClasses(new ClassDefinition[] {new ClassDefinition(c, bytes)});
          } catch (Throwable e) {
            synchronized (System.err) {
              System.err.println("" + c + " failed...");
              e.printStackTrace();
            }
          }
        }
        Runtime.getRuntime()
            .addShutdownHook(
                new Thread() {
                  public void run() {
                    Tracer.mark();
                    try {
                      PrintStream ps = new PrintStream("bailout.txt");
                      ps.println("Bailouts: " + Tracer.getBailoutCount());
                      ps.close();
                    } catch (Exception e) {
                    }
                    Tracer.unmark();
                  }
                });
        if ("true".equals(System.getProperty("bci.observerOn"))) Tracer.overrideAll(false);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Beispiel #2
0
  public static void main(String argv[]) {
    String[] file_name = new String[argv.length];
    int files = 0;
    ClassParser parser = null;
    JavaClass java_class = null;
    String zip_file = null;
    char sep = System.getProperty("file.separator").toCharArray()[0];
    String dir = "." + sep; // Where to store HTML files

    try {
      /* Parse command line arguments.
       */
      for (int i = 0; i < argv.length; i++) {
        if (argv[i].charAt(0) == '-') { // command line switch
          if (argv[i].equals("-d")) { // Specify target directory, default `.�
            dir = argv[++i];

            if (!dir.endsWith("" + sep)) dir = dir + sep;

            new File(dir).mkdirs(); // Create target directory if necessary
          } else if (argv[i].equals("-zip")) zip_file = argv[++i];
          else System.out.println("Unknown option " + argv[i]);
        } else // add file name to list */
        file_name[files++] = argv[i];
      }

      if (files == 0) System.err.println("Class2HTML: No input files specified.");
      else { // Loop through files ...
        for (int i = 0; i < files; i++) {
          System.out.print("Processing " + file_name[i] + "...");
          if (zip_file == null)
            parser = new ClassParser(file_name[i]); // Create parser object from file
          else
            parser = new ClassParser(zip_file, file_name[i]); // Create parser object from zip file

          java_class = parser.parse();
          new Class2HTML(java_class, dir);
          System.out.println("Done.");
        }
      }
    } catch (Exception e) {
      System.out.println(e);
      e.printStackTrace(System.out);
    }
  }
Beispiel #3
0
  public void dump(PrintWriter out, PrintWriter outLinkInfo) {

    int i;

    out.println("//");
    out.println("//\t" + classRefAddress + ": " + clazz.getClassName() + " class info");
    out.println("//");
    out.println("\t\t" + instSize + ",\t//\tinstance size");
    for (i = 0; i < clft.len; ++i) {
      if (!clft.isStatic[i]) {
        out.println("\t\t\t\t//\t" + clft.idx[i] + " " + clft.key[i]);
      }
    }
    // link info: class addresses
    outLinkInfo.println(
        "class " + clazz.getClassName() + " " + methodsAddress + " " + cpoolAddress);
    outLinkInfo.println(" -instSize " + instSize);

    out.println("\t\t" + staticValueVarAddress + ",\t//\tpointer to static primitive fields");
    if (instSize > 31) {
      System.err.println("Error: Object of " + clazz.getClassName() + " to big! Size=" + instSize);
      System.exit(-1);
    }
    out.println("\t\t" + instGCinfo + ",\t//\tinstance GC info");

    String supname = "null";
    int superAddr = 0;
    if (superClass != null) {
      supname = superClass.clazz.getClassName();
      superAddr = ((JopClassInfo) appInfo.cliMap.get(supname)).classRefAddress;
    }
    if (!clazz.isInterface()) {
      out.println("\t\t" + superAddr + ",\t//\tpointer to super class - " + supname);
      // link info: super address
      outLinkInfo.println(" -super " + superAddr);
    } else {
      out.println("\t\t" + (-interfaceID) + ",\t//\tinterface ID");
    }

    boolean useSuperInterfaceTable = false;
    if ((iftableAddress == 0) && (superClass != null)) {
      iftableAddress = ((JopClassInfo) appInfo.cliMap.get(supname)).iftableAddress;
      useSuperInterfaceTable = true;
    }
    out.println("\t\t" + iftableAddress + ",\t//\tpointer to interface table");

    if (!clazz.isInterface()) {
      out.println("//");
      out.println("//\t" + methodsAddress + ": " + clazz.getClassName() + " method table");
      out.println("//");

      int addr = methodsAddress;
      for (i = 0; i < clvt.len; i++) {
        clvt.mi[i].dumpMethodStruct(out, addr);
        outLinkInfo.println(" -mtab " + clvt.mi[i].getFQMethodName() + " " + addr);
        addr += ClassStructConstants.METH_STR;
      }
    } else {
      out.println("//");
      out.println("//\tno method table for interfaces");
      out.println("//");
    }

    out.println();
    out.println("\t\t" + classRefAddress + ",\t//\tpointer back to class struct (cp-1)");
    out.println();

    out.println("//");
    out.println("//\t" + cpoolAddress + ": " + clazz.getClassName() + " constants");
    out.println("//");

    // link info: constant pool mapping
    for (Entry<Integer, Integer> entry : cpoolMap.entrySet()) {
      outLinkInfo.println(" -constmap " + entry.getKey() + " " + entry.getValue());
    }

    // constant pool length includes the length field
    // same is true for the index in the bytecodes:
    // The lowest constant has index 1.
    out.println("\t\t" + (cpoolArry.length + 1) + ",\t//\tconst pool length");
    out.println();
    for (i = 0; i < cpoolArry.length; ++i) {
      out.println("\t\t" + cpoolArry[i] + ",\t//\t" + cpoolComments[i]);
    }

    if (iftableAddress != 0 && !useSuperInterfaceTable) {

      out.println("//");
      out.println(
          "//\t"
              + (iftableAddress - (interfaceCnt + 31) / 32)
              + ": "
              + clazz.getClassName()
              + " implements table");
      out.println("//");
      for (i = (interfaceCnt + 31) / 32 - 1; i >= 0; i--) {
        String comment = "";
        int word = 0;
        int j;
        for (j = 31; j >= 0; j--) {
          word <<= 1;
          if ((i * 32 + j) < interfaceCnt) {
            if (implementsInterface(interfaceList.get(i * 32 + j))) {
              word |= 1;
              comment += interfaceList.get(i * 32 + j) + ", ";
            }
            ;
          }
        }
        out.println("\t\t" + word + ",\t//\t" + comment);
      }

      out.println("//");
      out.println("//\t" + iftableAddress + ": " + clazz.getClassName() + " interface table");
      out.println("//");
      if (!clazz.isInterface()) {
        out.println("//\tTODO: is it enough to use methodId as key???");
        out.println("//");
        for (i = 0; i < listIT.size(); ++i) {
          IT it = (IT) listIT.get(i);
          int j;
          for (j = 0; j < clvt.len; j++) {
            if (clvt.key[j].equals(it.key)) {
              break;
            }
          }
          if (j != clvt.len) {
            out.print("\t\t" + (methodsAddress + j * ClassStructConstants.METH_STR) + ",");
          } else {
            out.print("\t\t" + 0 + ",\t");
          }
          out.println("\t//\t" + it.meth.methodId);
        }
      }
    }
  }
Beispiel #4
0
  /** @param cp */
  public void resolveCPool(ConstantPool cp) {

    Constant[] ca = cp.getConstantPool();
    cpoolArry = new int[cpoolUsed.size()];
    cpoolComments = new String[ca.length];

    // System.out.println(clazz.getClassName()+" cpool "+cpoolUsed);

    for (int i = 0; i < ca.length; ++i) {
      Constant co = ca[i];
      Integer idx = new Integer(i);
      // pos is the new position in the reduced constant pool
      // idx is the position in the 'original' unresolved cpool
      int pos = cpoolUsed.indexOf(idx);
      if (pos != -1) {
        boolean isInterface = false;
        // System.out.println("cpool@"+pos+" = orig_cp@"+i+" "+co);
        switch (co.getTag()) {
          case Constants.CONSTANT_Integer:
            cpoolArry[pos] = ((ConstantInteger) co).getBytes();
            cpoolComments[pos] = "Integer";
            break;
          case Constants.CONSTANT_Long:
            long lval = ((ConstantLong) co).getBytes();
            // store LOW, HIGH words in this order
            int loW = (new Long(0xFFFFFFFF & lval)).intValue();
            int hiW = (new Long(lval >>> 32)).intValue();
            cpoolArry[pos] = hiW;
            cpoolArry[pos + 1] = loW;
            cpoolComments[pos] = "Long: " + lval;
            cpoolComments[pos + 1] = "";
            break;
          case Constants.CONSTANT_Float:
            float fval = ((ConstantFloat) co).getBytes();
            cpoolArry[pos] = Float.floatToRawIntBits(fval);
            cpoolComments[pos] = "Float: " + fval;
            break;
          case Constants.CONSTANT_Double:
            double dval = ((ConstantDouble) co).getBytes();
            long d_lval = Double.doubleToRawLongBits(dval);
            // store LOW, HIGH words in this order
            int d_loW = (new Long(0xFFFFFFFF & d_lval)).intValue();
            int d_hiW = (new Long(d_lval >>> 32)).intValue();
            cpoolArry[pos] = d_hiW;
            cpoolArry[pos + 1] = d_loW;
            cpoolComments[pos] = "Double: " + dval;
            cpoolComments[pos + 1] = "";
            break;
          case Constants.CONSTANT_String:
            String str = ((ConstantString) co).getBytes(cp);
            StringInfo si = StringInfo.getStringInfo(str);
            cpoolArry[pos] = StringInfo.stringTableAddress + si.getAddress();
            cpoolComments[pos] = "String: " + si.getSaveString();
            break;
          case Constants.CONSTANT_Class:
            String clname = ((ConstantClass) co).getBytes(cp).replace('/', '.');
            JopClassInfo clinfo = (JopClassInfo) appInfo.cliMap.get(clname);
            if (clinfo == null) {
              cpoolComments[pos] = "Problem with class: " + clname;
              String type = clname.substring(clname.length() - 2);
              if (type.charAt(0) == '[') {
                switch (type.charAt(1)) {
                  case 'Z':
                    cpoolArry[pos] = 4;
                    break;
                  case 'C':
                    cpoolArry[pos] = 5;
                    break;
                  case 'F':
                    cpoolArry[pos] = 6;
                    break;
                  case 'D':
                    cpoolArry[pos] = 7;
                    break;
                  case 'B':
                    cpoolArry[pos] = 8;
                    break;
                  case 'S':
                    cpoolArry[pos] = 9;
                    break;
                  case 'I':
                    cpoolArry[pos] = 10;
                    break;
                  case 'J':
                    cpoolArry[pos] = 11;
                    break;
                  default:; // all other types are missing...
                }
              }
              // System.out.println(cpoolComments[pos]+" "+type+" "+cpoolArry[pos]);
              continue;
            }
            cpoolArry[pos] = clinfo.classRefAddress;
            cpoolComments[pos] = "Class: " + clname;
            break;
          case Constants.CONSTANT_InterfaceMethodref:
            isInterface = true;
          case Constants.CONSTANT_Methodref:
            // find the class for this method
            int mclidx;
            if (isInterface) {
              mclidx = ((ConstantInterfaceMethodref) co).getClassIndex();
            } else {
              mclidx = ((ConstantMethodref) co).getClassIndex();
            }
            ConstantClass mcl = (ConstantClass) cp.getConstant(mclidx);
            // the method has "/" instead of ".", fix that
            // now get the signature too...
            String mclname = mcl.getBytes(cp).replace('/', '.');
            int sigidx;
            if (isInterface) {
              sigidx = ((ConstantInterfaceMethodref) co).getNameAndTypeIndex();
            } else {
              sigidx = ((ConstantMethodref) co).getNameAndTypeIndex();
            }
            ConstantNameAndType signt = (ConstantNameAndType) cp.getConstant(sigidx);
            String sigstr = signt.getName(cp) + signt.getSignature(cp);
            // now find the address of the method struct!
            JopClassInfo clinf = (JopClassInfo) appInfo.cliMap.get(mclname);
            if (clinf == null) {
              // probably a reference to Native - a class that
              // is NOT present in the application.
              // we could avoid this by not adding method refs to
              // Native in our reduced cpool.
              cpoolArry[pos] = 0;
              cpoolComments[pos] = "static " + mclname + "." + sigstr;
              break;
            }
            JopMethodInfo minf;
            if (isInterface) {
              minf = clinf.getITMethodInfo(sigstr);
            } else {
              minf = clinf.getVTMethodInfo(sigstr);
            }
            if (minf == null) {
              System.out.println(
                  "Error: Method " + clinf.clazz.getClassName() + '.' + sigstr + " not found.");
              System.out.println("Invoked by " + clazz.getClassName());
              for (int xxx = 0; xxx < clinf.clvt.len; ++xxx) {
                System.out.println(clinf.clvt.key[xxx]);
              }
              System.exit(1);
            }
            if (minf.getMethod().isStatic()
                ||
                // <init> and privat methods are called with invokespecial
                // which mapps in jvm.asm to invokestatic
                minf.getMethod().isPrivate()
                || sigstr.charAt(0) == '<') {
              // for static methods a direct pointer to the
              // method struct
              cpoolArry[pos] = minf.structAddress;
              cpoolComments[pos] =
                  "static, special or private " + clinf.clazz.getClassName() + "." + minf.methodId;
            } else {
              // as Flavius correctly comments:
              // TODO: CHANGE THIS TO A MORE CONSISTENT FORMAT...
              // extract the objref! for some reason the microcode
              // needs -1 here...weird

              // that's for simple virtual methods
              int vpos = minf.vtindex;
              String comment = "virtual";

              // TODO: is kind of redundant search as we've already
              // searched the IT table with getVTMethodInfo()
              // TODO: do we handle different interfaces with same
              // method id correct? (see buildIT)
              if (isInterface) {
                comment = "interface";
                for (int j = 0; j < listIT.size(); ++j) {
                  IT it = (IT) listIT.get(j);
                  if (it.key.equals(minf.methodId)) {
                    vpos = j;
                    break;
                  }
                }
                // offest in interface table
                // index plus number of arguments (without this!)
                cpoolArry[pos] = (vpos << 8) + (minf.margs - 1);
              } else {
                // offest in method table
                // (index*2) plus number of arguments (without
                // this!)
                cpoolArry[pos] = (vpos * ClassStructConstants.METH_STR << 8) + (minf.margs - 1);
              }
              cpoolComments[pos] =
                  comment
                      + " index: "
                      + vpos
                      + " args: "
                      + minf.margs
                      + " "
                      + clinf.clazz.getClassName()
                      + "."
                      + minf.methodId;
            }
            break;
          case Constants.CONSTANT_Fieldref:
            throw new Error("Fieldref should not be used anymore");
            //					int fidx = ((ConstantFieldref) co).getClassIndex();
            //					ConstantClass fcl = (ConstantClass) cp.getConstant(fidx);
            //					String fclname = fcl.getBytes(cp).replace('/', '.');
            //					// got the class name
            //					sigidx = ((ConstantFieldref) co).getNameAndTypeIndex();
            //					signt = (ConstantNameAndType) cp.getConstant(sigidx);
            //					sigstr = signt.getName(cp) + signt.getSignature(cp);
            //					clinf = (JopClassInfo) appInfo.cliMap.get(fclname);
            //					int j;
            //					String comment = "";
            //					boolean found = false;
            //					while (!found) {
            //						for (j = 0; j < clinf.clft.len; ++j) {
            //							if (clinf.clft.key[j].equals(sigstr)) {
            //								found = true;
            //								if (clinf.clft.isStatic[j]) {
            //									comment = "static ";
            //								}
            //								// for static fields a direct pointer to the
            //								// static field
            //								cpoolArry[pos] = clinf.clft.idx[j];
            //								cpoolComments[pos] = comment
            //										+ clinf.clazz.getClassName() + "."
            //										+ sigstr;
            //								break;
            //							}
            //						}
            //						if (!found) {
            //							clinf = (JopClassInfo) clinf.superClass;
            //							if (clinf == null) {
            //								System.out.println("Error: field " + fclname
            //										+ "." + sigstr + " not found!");
            //								break;
            //							}
            //						}
            //					}
            //					break;
          default:
            System.out.println("TODO: cpool@" + pos + " = orig_cp@" + i + " " + co);
            cpoolComments[pos] = "Problem with: " + co;
        }
      }
    }
  }