/** * Should be called Before virtual execution of instructions putfield and putstatic so that all * corresponding getFields are set dirty. Similarly should also be called before virtual execution * of instructions AASTORE so that corresponding AALOAD are set dirty. * * @param method * @param callingParms * @param instr * @param stack * @param localVariables */ public void fixOrderRelatedInstrs( MethodInfo method, Vector callingParms, GCInstruction instr, GCOperandStack stack, GCLocalVariables localVariables) { if (!isFieldIsObjectBased(instr)) { return; } String methodStr = oracle.getMethodOrFieldString(method); if (instr.getOpCode() == JavaInstructionsOpcodes.PUTSTATIC || instr.getOpCode() == JavaInstructionsOpcodes.PUTFIELD || instr.getOpCode() == JavaInstructionsOpcodes.AASTORE) { GCType type = (GCType) stack.peep(); if (!type.isReference()) { return; } HashSet<TTReference> refSet = type.getReferences(); if (refSet.size() == 1) { TTReference ref = refSet.iterator().next(); if (ref.getClassThisPointer() == Type.NULL || ref.getNewId() < 0) { return; } } debugPrint("\n\n++++++++++ ", "fix-Order"); debugPrint("method Str =", oracle.getMethodOrFieldString(method)); debugPrint("instr =", instr); handlePutRecalls(new MethodCallInfo(method, callingParms), instr, stack); } }
/** * In case the method is still under-call then put the record of the method fields where get was * used in a seperate map. When a method any next instruction is called again then the record is * pop from the map and corresponding instructions are made dirty. * * <p>This method create that record of method fields. * * @param methodCallInfo * @param instrDataSettingInstr */ private void handlePutRecalls( MethodCallInfo methodCallInfo, GCInstruction instrDataSettingInstr, OperandStack stack) { if (true) return; try { /** * 1. Firstly get from input instructions the uniqueId for corresponding data reterival * instructions. 2. Subsequently, add those instructions in the two different maps depending * upon if the method is still under call or not. */ ControllerForFieldInstr contr = ControllerForFieldInstr.getInstanceOf(); HashSet<Integer> uniqueIdForDataRetrivalInstr = new HashSet<Integer>(); if (instrDataSettingInstr.getOpCode() != JavaInstructionsOpcodes.AASTORE) { int cpIndex = instrDataSettingInstr.getOperandsData().intValueUnsigned(); uniqueIdForDataRetrivalInstr.add(cpIndex); } else { uniqueIdForDataRetrivalInstr = getAAStoreNewIds(stack); } /** * following are the all getField or getStatic instruction for the given constant pool index. */ HashSet<FieldRecord> getFieldOrStateRecordSet = contr.getRecords( uniqueIdForDataRetrivalInstr, instrDataSettingInstr.getOpCode() == JavaInstructionsOpcodes.AASTORE); /** * Now we iterate from all of those instructions and put them in two different maps * depenending up if their method is still under call or not. */ Iterator<FieldRecord> fieldRectIt = getFieldOrStateRecordSet.iterator(); while (fieldRectIt.hasNext()) { FieldRecord fieldRec = fieldRectIt.next(); HashSet<FunctionStateKey> allTheMethodCallsForTheField = fieldRec.getStateKeys(); Iterator<FunctionStateKey> methodCallIt = allTheMethodCallsForTheField.iterator(); while (methodCallIt.hasNext()) { FunctionStateKey stateKey = methodCallIt.next(); GCDataFlowAnalyzer dataFlowAnalyzer = GCDataFlowAnalyzer.getInstanceOf(); HashSet<FunctionStateKey> allMethodInExecution = dataFlowAnalyzer.getMethodsInExecution(); String methodString = oracle.getMethodOrFieldString(stateKey.getMethod()); long instrId = fieldRec.getInstr().getInstructionId(); if (allMethodInExecution.contains(stateKey)) { putInMap(fieldsToSetDirtyInUnderCallMethod, stateKey, fieldRec); } else { putInMap(fieldsToSetDirtyAfterMethodCalled, stateKey, fieldRec); } } } } catch (Exception d) { d.printStackTrace(); Miscellaneous.exit(); } }
public static List<Pair<GreedyState, String[]>> run(GreedyState state, Oracle oracle) { List<Pair<GreedyState, String[]>> decisions = new ArrayList<>(); // Add state progressions and oracle decisions while (!state.finished) { String[] decision = oracle.predictArcs(state); decisions.add(new Pair<>(state, decision)); state = state.transition(decision); } // Add final state decisions.add(new Pair<>(state, null)); return decisions; }
@Override public void execute(String args[]) throws Exception { try { statHolder.addStat( StatGroups.BYTECODE_OPTIMIZATION, "Total size of all instructions ", CodeAtt.getCodeTotalLengthInput()); super.execute(args); if (!doOptimization) { return; } InputOptionsController.getInstanceOf().execute(); endWithOptimization = true; Oracle.getInstanceOf().updateAllCodeAttsLength(); } catch (Exception d) { d.printStackTrace(); Miscellaneous.exit(); } }
private static DatabaseClient.Builder newBuilderForUrl(String url) { DatabaseClient.Builder builder; if (isEmpty(url) || url.startsWith("jdbc:h2:")) { builder = H2.builder(); } else if (url.startsWith("jdbc:oracle:")) { builder = Oracle.builder(); } else if (url.startsWith("jdbc:mysql:")) { builder = MySql.builder(); } else if (url.startsWith("jdbc:jtds:")) { builder = MsSql.jtdsBuilder(); } else if (url.startsWith("jdbc:sqlserver:")) { builder = MsSql.msBuilder(); } else if (url.startsWith("jdbc:postgresql:")) { builder = PostgreSql.builder(); } else { throw new IllegalArgumentException("Unsupported DB: " + url); } if (!isEmpty(url)) { builder.setUrl(url); } return builder; }
/** * Call it BEFORE executing an instruction virtually. * * @param instr * @param stack * @param localVar */ private void addRecord( FunctionStateKey stateKey, GCInstruction instr, GCOperandStack stack, GCLocalVariables localVar) { MethodInfo method = instr.getMethod(); String methodStr = oracle.getMethodOrFieldString(method); if (methodStr.contains("jvmTestCases.Main.fooGetOnly")) {} debugPrint("\n\n", "***** adding record *****"); debugPrint("method Str=", methodStr); debugPrint("instr =", instr); HashSet<Integer> unqiueForField = new HashSet<Integer>(); if (instr.getOpCode() != JavaInstructionsOpcodes.AALOAD) { int cpIndex = instr.getOperandsData().intValueUnsigned(); unqiueForField.add(cpIndex); } else { unqiueForField = getAALOADNewIds(stack); } Iterator<Integer> it = unqiueForField.iterator(); while (it.hasNext()) { contrForField.addRecord(stateKey, instr, it.next()); } }
/** * Title: * * <p>Description: * * @author Faisal Aslam * @version 1.0 */ public class OrderManagerForFieldInstrs implements FSKAsHashKeyInterface { private static final OrderManagerForFieldInstrs myObj = new OrderManagerForFieldInstrs(); private ControllerForFieldInstr contrForField = ControllerForFieldInstr.getInstanceOf(); /** value = HashSet<FieldRecord> */ private HashMap<FunctionStateKey, FunctionStateKeyMapValue> fieldsToSetDirtyInUnderCallMethod = new HashMap<FunctionStateKey, FunctionStateKeyMapValue>(); private HashMap<FunctionStateKey, FunctionStateKeyMapValue> fieldsToSetDirtyAfterMethodCalled = new HashMap<FunctionStateKey, FunctionStateKeyMapValue>(); private Oracle oracle = Oracle.getInstanceOf(); private static boolean shouldDebugPrint = false; public static void debugPrint(Object obj1, Object obj2) { if (shouldDebugPrint) { System.out.println(obj1 + "" + obj2); } } private OrderManagerForFieldInstrs() {} public void updateHashMapUsingFSK() { FunctionStateKeyMapValue.update(fieldsToSetDirtyInUnderCallMethod); FunctionStateKeyMapValue.update(fieldsToSetDirtyAfterMethodCalled); } public static OrderManagerForFieldInstrs getInstanceOf() { return myObj; } /** * This method is called when GetStatic or GetField or AALoad. It adds record of those * instructions so that they can be made dirty when putfield or putstatic is used for the same * field. * * @param method * @param callingParams * @param instr * @param stack * @param localVar */ public void addRecord( MethodInfo method, Vector callingParams, GCInstruction instr, GCOperandStack stack, GCLocalVariables localVar) { if (!isFieldIsObjectBased(instr) || (instr.getOpCode() != JavaInstructionsOpcodes.GETSTATIC && instr.getOpCode() != JavaInstructionsOpcodes.GETFIELD && instr.getOpCode() != JavaInstructionsOpcodes.AALOAD)) { return; } addRecord(new FunctionStateKey(method, callingParams), instr, stack, localVar); } /** * Should be called Before virtual execution of instructions putfield and putstatic so that all * corresponding getFields are set dirty. Similarly should also be called before virtual execution * of instructions AASTORE so that corresponding AALOAD are set dirty. * * @param method * @param callingParms * @param instr * @param stack * @param localVariables */ public void fixOrderRelatedInstrs( MethodInfo method, Vector callingParms, GCInstruction instr, GCOperandStack stack, GCLocalVariables localVariables) { if (!isFieldIsObjectBased(instr)) { return; } String methodStr = oracle.getMethodOrFieldString(method); if (instr.getOpCode() == JavaInstructionsOpcodes.PUTSTATIC || instr.getOpCode() == JavaInstructionsOpcodes.PUTFIELD || instr.getOpCode() == JavaInstructionsOpcodes.AASTORE) { GCType type = (GCType) stack.peep(); if (!type.isReference()) { return; } HashSet<TTReference> refSet = type.getReferences(); if (refSet.size() == 1) { TTReference ref = refSet.iterator().next(); if (ref.getClassThisPointer() == Type.NULL || ref.getNewId() < 0) { return; } } debugPrint("\n\n++++++++++ ", "fix-Order"); debugPrint("method Str =", oracle.getMethodOrFieldString(method)); debugPrint("instr =", instr); handlePutRecalls(new MethodCallInfo(method, callingParms), instr, stack); } } private void putInMap( HashMap<FunctionStateKey, FunctionStateKeyMapValue> map, FunctionStateKey callInfo, FieldRecord getFieldRecord) { FunctionStateKeyMapValue specialValue = map.get(callInfo); HashSet<FieldRecord> value = null; if (specialValue == null) { value = new HashSet<FieldRecord>(); specialValue = new FunctionStateKeyMapValue(callInfo, value); map.put(callInfo, specialValue); value.add(getFieldRecord); } else { value = (HashSet<FieldRecord>) specialValue.getValue(); value.add(getFieldRecord); } } public void removeForMapForDirtyGetFieldInstr(FunctionStateKey methodCallInfo) { fieldsToSetDirtyAfterMethodCalled.remove(methodCallInfo); } public HashMap<FunctionStateKey, FunctionStateKeyMapValue> getAfterCallMethodWithDirtyGetFieldInstr() { return fieldsToSetDirtyAfterMethodCalled; } public HashSet<FieldRecord> getAndRemoveUnderExecMethodWithDirtyGetFieldInstr( FunctionStateKey methodCallInfo) { FunctionStateKeyMapValue value = fieldsToSetDirtyInUnderCallMethod.remove(methodCallInfo); if (value == null) { return null; } return (HashSet<FieldRecord>) value.getValue(); } /** * In case the method is still under-call then put the record of the method fields where get was * used in a seperate map. When a method any next instruction is called again then the record is * pop from the map and corresponding instructions are made dirty. * * <p>This method create that record of method fields. * * @param methodCallInfo * @param instrDataSettingInstr */ private void handlePutRecalls( MethodCallInfo methodCallInfo, GCInstruction instrDataSettingInstr, OperandStack stack) { if (true) return; try { /** * 1. Firstly get from input instructions the uniqueId for corresponding data reterival * instructions. 2. Subsequently, add those instructions in the two different maps depending * upon if the method is still under call or not. */ ControllerForFieldInstr contr = ControllerForFieldInstr.getInstanceOf(); HashSet<Integer> uniqueIdForDataRetrivalInstr = new HashSet<Integer>(); if (instrDataSettingInstr.getOpCode() != JavaInstructionsOpcodes.AASTORE) { int cpIndex = instrDataSettingInstr.getOperandsData().intValueUnsigned(); uniqueIdForDataRetrivalInstr.add(cpIndex); } else { uniqueIdForDataRetrivalInstr = getAAStoreNewIds(stack); } /** * following are the all getField or getStatic instruction for the given constant pool index. */ HashSet<FieldRecord> getFieldOrStateRecordSet = contr.getRecords( uniqueIdForDataRetrivalInstr, instrDataSettingInstr.getOpCode() == JavaInstructionsOpcodes.AASTORE); /** * Now we iterate from all of those instructions and put them in two different maps * depenending up if their method is still under call or not. */ Iterator<FieldRecord> fieldRectIt = getFieldOrStateRecordSet.iterator(); while (fieldRectIt.hasNext()) { FieldRecord fieldRec = fieldRectIt.next(); HashSet<FunctionStateKey> allTheMethodCallsForTheField = fieldRec.getStateKeys(); Iterator<FunctionStateKey> methodCallIt = allTheMethodCallsForTheField.iterator(); while (methodCallIt.hasNext()) { FunctionStateKey stateKey = methodCallIt.next(); GCDataFlowAnalyzer dataFlowAnalyzer = GCDataFlowAnalyzer.getInstanceOf(); HashSet<FunctionStateKey> allMethodInExecution = dataFlowAnalyzer.getMethodsInExecution(); String methodString = oracle.getMethodOrFieldString(stateKey.getMethod()); long instrId = fieldRec.getInstr().getInstructionId(); if (allMethodInExecution.contains(stateKey)) { putInMap(fieldsToSetDirtyInUnderCallMethod, stateKey, fieldRec); } else { putInMap(fieldsToSetDirtyAfterMethodCalled, stateKey, fieldRec); } } } } catch (Exception d) { d.printStackTrace(); Miscellaneous.exit(); } } /** * Call it BEFORE executing an instruction virtually. * * @param instr * @param stack * @param localVar */ private void addRecord( FunctionStateKey stateKey, GCInstruction instr, GCOperandStack stack, GCLocalVariables localVar) { MethodInfo method = instr.getMethod(); String methodStr = oracle.getMethodOrFieldString(method); if (methodStr.contains("jvmTestCases.Main.fooGetOnly")) {} debugPrint("\n\n", "***** adding record *****"); debugPrint("method Str=", methodStr); debugPrint("instr =", instr); HashSet<Integer> unqiueForField = new HashSet<Integer>(); if (instr.getOpCode() != JavaInstructionsOpcodes.AALOAD) { int cpIndex = instr.getOperandsData().intValueUnsigned(); unqiueForField.add(cpIndex); } else { unqiueForField = getAALOADNewIds(stack); } Iterator<Integer> it = unqiueForField.iterator(); while (it.hasNext()) { contrForField.addRecord(stateKey, instr, it.next()); } } private HashSet<Integer> getAAStoreNewIds(OperandStack stack) { int currentSizeOfStack = stack.getCurrentSize(); GCType type = (GCType) stack.get(currentSizeOfStack - 3); HashSet<Integer> toRet = type.getAllNewIds(); toRet.remove(-1); return toRet; } private HashSet<Integer> getAALOADNewIds(OperandStack stack) { HashSet<Integer> toRet = new HashSet<Integer>(); try { int currentSizeOfStack = stack.getNumberOfTypesInStack(); GCType type = (GCType) stack.get(currentSizeOfStack - 2); toRet = type.getAllNewIds(); toRet.remove(-1); } catch (Exception d) { d.printStackTrace(); System.exit(1); } return toRet; } /** * check if the field saves an object. * * @param instr * @return */ private boolean isFieldIsObjectBased(GCInstruction instr) { if (instr.getOpCode() == JavaInstructionsOpcodes.AALOAD || instr.getOpCode() == JavaInstructionsOpcodes.AASTORE) { return true; } if (instr.getOpCode() != JavaInstructionsOpcodes.PUTFIELD && instr.getOpCode() != JavaInstructionsOpcodes.GETFIELD && instr.getOpCode() != JavaInstructionsOpcodes.GETSTATIC && instr.getOpCode() != JavaInstructionsOpcodes.PUTSTATIC) { return false; } GlobalConstantPool pOne = GlobalConstantPool.getInstanceOf(); int index = instr.getOperandsData().intValueUnsigned(); FieldRefInfo fInfo = (FieldRefInfo) pOne.get(index, TagValues.CONSTANT_Fieldref); int nameAndTypeIndex = fInfo.getNameAndTypeIndex().intValueUnsigned(); NameAndTypeInfo nAtInfo = (NameAndTypeInfo) pOne.get(nameAndTypeIndex, TagValues.CONSTANT_NameAndType); String description = ((UTF8Info) pOne.get(nAtInfo.getDescriptorIndex().intValueUnsigned(), TagValues.CONSTANT_Utf8)) .convertBytes(); VerificationFrameFactory frameFactory = VerificationPlaceHolder.getInstanceOf().getFactory(); Type fieldType = frameFactory.createType(); InitializeFirstInstruction.getType(description, 0, fieldType); return fieldType.isReference(); } }
private static void executeOS( String sourceType, String sourceServer, String sourceInstance, int sourcePort, String sourceDatabase, String sourceSchema, String sourceTable, String refreshType, String appendColumnName, int appendColumnMax, Connection gpConn, int queueId) throws Exception { String method = "executeOS"; int location = 1000; String sourceUser = ""; String sourcePass = ""; String strSQL = ""; int fetchSize = 10; Connection conn = null; try { location = 3000; ResultSet rs; Statement stmt; location = 3010; strSQL = GP.getQueueDetails(gpConn, queueId); location = 3020; stmt = gpConn.createStatement(); location = 3040; rs = stmt.executeQuery(strSQL); while (rs.next()) { sourceUser = rs.getString(1); sourcePass = rs.getString(2); } location = 3090; if (sourceType.equals("sqlserver")) { location = 3100; conn = CommonDB.connectSQLServer(sourceServer, sourceInstance, sourceUser, sourcePass); location = 3200; // create SQL statement for selecting data strSQL = SQLServer.getSQLForData( conn, sourceDatabase, sourceSchema, sourceTable, refreshType, appendColumnName, appendColumnMax); location = 3300; // execute the SQL Statement CommonDB.outputData(conn, strSQL); location = 3400; conn.close(); } else if (sourceType.equals("oracle")) { location = 4000; fetchSize = Integer.parseInt(GP.getVariable(gpConn, "oFetchSize")); location = 4100; conn = CommonDB.connectOracle( sourceServer, sourceDatabase, sourcePort, sourceUser, sourcePass, fetchSize); location = 4200; // execute the SQL Statement strSQL = Oracle.getSQLForData( conn, sourceSchema, sourceTable, refreshType, appendColumnName, appendColumnMax); location = 4300; // execute the SQL Statement CommonDB.outputData(conn, strSQL); location = 4400; conn.close(); } } catch (SQLException ex) { throw new SQLException( "(" + myclass + ":" + method + ":" + location + ":" + ex.getMessage() + ")"); } finally { if (conn != null) conn.close(); } }