Should be enabled again with `reEnableLog()`
- */
- public static void disableSymbolicTracking() {
- ThreadHandler.disableThreadContext(currentThread().getId());
- }
-
- /**
- * Re-enable the logger, e.g. after a class has been loaded. Before re-enabling
- * `temporaryDisableLog` has to be called.
- */
- public static void enableSymbolicTracking() {
- ThreadHandler.enableThreadContext(currentThread().getId());
- }
-
- /**
- * Initializes symbolic or coverage only tracking for the current execution. The method call is
- * added during instrumentation
- *
- * @param endpoint The name of the endpoint.
- */
- public static void init(String endpoint) {
- int endpointID;
- if (config.getInstrumentationTransformer().equals(TransformerType.SV_COMP)) {
- endpointID = 0;
- } else {
- endpointID = endpoint.hashCode();
- }
- ThreadHandler.addThreadContext(currentThread().getId());
- ThreadHandler.setEndpointID(currentThread().getId(), endpointID);
- ThreadHandler.setEndpointName(currentThread().getId(), endpoint);
-
- logger.info(
- new PrintBox(
- 60,
- "Symbolic execution started (Thread: "
- + Thread.currentThread().getId()
- + ")",
- new ArrayList<>(
- List.of(
- new String[] {
- "Execution started (Thread: "
- + Thread.currentThread().getId()
- + ")",
- "Threads (tracked / active): ("
- + ThreadHandler.getThreadCount()
- + " / "
- + Thread.activeCount()
- + ")",
- "Method: " + endpoint,
- "ID: " + endpointID
- })))
- .toString());
- }
-
- /**
- * Finishes symbolic tracking and initializes constrain transfer to coordinator. Method call
- * added during instrumentation.
- */
- public static void terminate() {
- ThreadHandler.disableThreadContext(currentThread().getId());
- logger.info(
- new PrintBox(
- 60,
- "Symbolic execution finished (Thread: "
- + currentThread().getId()
- + ")",
- new ArrayList<>(
- List.of(
- new String[] {
- "Threads (tracked / active): ("
- + ThreadHandler.getThreadCount()
- + " / "
- + Thread.activeCount()
- + ")",
- })))
- .toString());
-
- switch (config.getSolverMode()) {
- case LOCAL:
- LocalSolver.solve();
- break;
- case HTTP:
- ThreadHandler.sendData(currentThread().getId());
- break;
- default:
- throw new RuntimeException("Unknown solver request");
- }
-
- SymbolicInstructionDispatcher.flush(); // TODO WTF does that do? calls log(null)
- ThreadHandler.removeSolverContext(currentThread().getId());
- ThreadHandler.removeThreadContext(currentThread().getId());
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param intValue The concrete value to be considered for symbolic analysis.
- * @return The original long value, with instrumentation logic potentially applied during
- * runtime.
- */
- @SuppressWarnings("unused")
- public static int MakeSymbolic(int intValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + intValue);
- return intValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param longValue The concrete long value to be considered for symbolic analysis.
- * @return The original long value, with instrumentation logic potentially applied during
- * runtime.
- */
- @SuppressWarnings("unused")
- public static long MakeSymbolic(long longValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + longValue);
- return longValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param charValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static char MakeSymbolic(char charValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + charValue);
- return charValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param byteValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static byte MakeSymbolic(byte byteValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + byteValue);
- return byteValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param shortValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static short MakeSymbolic(short shortValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + shortValue);
- return shortValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param boolValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static boolean MakeSymbolic(boolean boolValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + boolValue);
- return boolValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param stringValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static String MakeSymbolic(String stringValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + stringValue);
- return stringValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param floatValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static float MakeSymbolic(float floatValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value: " + floatValue);
- return floatValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param doubleValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static double MakeSymbolic(double doubleValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + doubleValue);
- return doubleValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param longValue The concrete value to be considered for symbolic analysis.
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static Long MakeSymbolic(Long longValue) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + longValue);
- return longValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param intValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static int MakeSymbolic(int intValue, String namePrefix) {
- logger.info(
- "[DSE] Initializing symbolic tracking for the following value "
- + intValue
- + " with identifier "
- + namePrefix);
- return intValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param longValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static long MakeSymbolic(long longValue, String namePrefix) {
- logger.info(
- "[DSE] Initializing symbolic tracking for the following value "
- + longValue
- + " with identifier "
- + namePrefix);
- return longValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param charValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static char MakeSymbolic(char charValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + charValue);
- return charValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param byteValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static byte MakeSymbolic(byte byteValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + byteValue);
- return byteValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param shortValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static short MakeSymbolic(short shortValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + shortValue);
- return shortValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param boolValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static boolean MakeSymbolic(boolean boolValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + boolValue);
- return boolValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param stringValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static String MakeSymbolic(String stringValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + stringValue);
- return stringValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param floatValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static float MakeSymbolic(float floatValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + floatValue);
- return floatValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param doubleValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static double MakeSymbolic(double doubleValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + doubleValue);
- return doubleValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param longValue The concrete value to be considered for symbolic analysis.
- * @param namePrefix The symbolic identifier of the variable
- * @return The original value, with instrumentation logic potentially applied during runtime.
- */
- @SuppressWarnings("unused")
- public static Long MakeSymbolic(Long longValue, String namePrefix) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + longValue);
- return longValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param intValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static int MakeSymbolic(int intValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + intValue);
- return intValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param longValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static long MakeSymbolic(long longValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + longValue);
- return longValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param charValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static char MakeSymbolic(char charValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + charValue);
- return charValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param byteValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static byte MakeSymbolic(byte byteValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + byteValue);
- return byteValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param shortValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static short MakeSymbolic(short shortValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + shortValue);
- return shortValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param boolValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static boolean MakeSymbolic(boolean boolValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + boolValue);
- return boolValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param stringValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static String MakeSymbolic(String stringValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + stringValue);
- return stringValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param floatValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static float MakeSymbolic(float floatValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + floatValue);
- return floatValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param doubleValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static double MakeSymbolic(double doubleValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + doubleValue);
- return doubleValue;
- }
-
- /**
- * A stub function for symbolic value creation. This method is intended to be instrumented
- * during runtime. The actual symbolic processing is performed elsewhere.
- *
- * @param longValue The concrete value
- * @param idx The index of the variable
- */
- @SuppressWarnings("unused")
- public static Long MakeSymbolic(Long longValue, long idx) {
- logger.info("[DSE] Initializing symbolic tracking for the following value " + longValue);
- return longValue;
- }
-
- /**
- * Stub function, call is added during instrumentation
- *
- * @param arg The value (argument) to check
- * @param identifier The type identifier of the arg
- * @param sink The identifier of the sink
- */
- @SuppressWarnings("unused")
- public static void checkSink(Object arg, String identifier, String sink) {}
-
- /**
- * Stub function, call is added during instrumentation
- *
- * @param arg1 The first value (argument) to check
- * @param arg2 The second value (argument) to check
- * @param identifier The type identifier of the arguments (arg1, arg2)
- * @param sink The identifier of the sink
- */
- @SuppressWarnings("unused")
- public static void checkSink(Object arg1, Object arg2, String identifier, String sink) {}
-
- /**
- * Stub function, call is added during instrumentation
- *
- * @param arg1 The first value (argument) to check
- * @param arg2 The second value (argument) to check
- * @param arg3 The third value (argument) to check
- * @param identifier The type identifier of the arguments (arg1, arg2, arg3)
- * @param sink The identifier of the sink
- */
- @SuppressWarnings("unused")
- public static void checkSink(
- Object arg1, Object arg2, Object arg3, String identifier, String sink) {}
-
- /**
- * Stub function, call is added during instrumentation
- *
- * @param arg1 The first value (argument) to check
- * @param arg2 The second value (argument) to check
- * @param arg3 The third value (argument) to check
- * @param arg4 The fourth value (argument) to check
- * @param identifier The type identifier of the arguments (arg1, arg2, arg3, arg4)
- * @param sink The identifier of the sink
- */
- @SuppressWarnings("unused")
- public static void checkSink(
- Object arg1, Object arg2, Object arg3, Object arg4, String identifier, String sink) {}
-
- /**
- * Stub function, call is added during instrumentation
- *
- * @param arg1 The first value (argument) to check
- * @param arg2 The second value (argument) to check
- * @param arg3 The third value (argument) to check
- * @param arg4 The fourth value (argument) to check
- * @param arg5 The fifth value (argument) to check
- * @param identifier The type identifier of the arguments (arg1, arg2, arg3, arg4, arg5)
- * @param sink The identifier of the sink
- */
- @SuppressWarnings("unused")
- public static void checkSink(
- Object arg1,
- Object arg2,
- Object arg3,
- Object arg4,
- Object arg5,
- String identifier,
- String sink) {}
-
- /**
- * Stub function, call is added during instrumentation
- *
- * @param arg1 The first value (argument) to check
- * @param arg2 The second value (argument) to check
- * @param arg3 The third value (argument) to check
- * @param arg4 The fourth value (argument) to check
- * @param arg5 The fifth value (argument) to check
- * @param arg6 The sixth value (argument) to check
- * @param identifier The type identifier of the arguments (arg1, arg2, arg3, arg4, arg5, arg6)
- * @param sink The identifier of the sink
- */
- @SuppressWarnings("unused")
- public static void checkSink(
- Object arg1,
- Object arg2,
- Object arg3,
- Object arg4,
- Object arg5,
- Object arg6,
- String identifier,
- String sink) {}
-}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/ErrorHandler.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/ErrorHandler.java
index e6000db..3da9545 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/common/ErrorHandler.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/ErrorHandler.java
@@ -1,14 +1,23 @@
package de.uzl.its.swat.common;
+import ch.qos.logback.classic.AsyncAppender;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.core.FileAppender;
+import de.uzl.its.swat.common.exceptions.SWATException;
+import de.uzl.its.swat.common.logging.GlobalLogger;
+import de.uzl.its.swat.common.logging.records.ErrorRecord;
import de.uzl.its.swat.config.Config;
-import org.slf4j.LoggerFactory;
+import de.uzl.its.swat.thread.ThreadHandler;
+import java.util.Arrays;
+
+import static java.lang.Thread.currentThread;
/**
* ErrorHandler is responsible for handling exceptions throughout the application. It decides
* whether to log the error or terminate the execution based on the application configuration.
*/
public class ErrorHandler {
- private static final org.slf4j.Logger logger = LoggerFactory.getLogger(ErrorHandler.class);
+ private static final Logger logger = GlobalLogger.getErrorLogger();
private final Config config;
@@ -27,6 +36,14 @@ public void handleException(Exception e) {
handleException("An error occurred, but was swallowed", e);
}
+ /**
+ * Raises a SWAT exception.
+ * @param msg the error message
+ */
+ public void raiseException(String msg) {
+ handleException(new SWATException(msg));
+ }
+
/**
* Handles an exception with a custom message. Depending on the application configuration, it
* either logs the error or terminates the execution by throwing a RuntimeException.
@@ -35,18 +52,65 @@ public void handleException(Exception e) {
* @param t the throwable to handle
*/
public void handleException(String msg, Throwable t) {
- if (config.isExitOnError()) {
- // Consider a more specific custom exception or handling strategy
- throw new SWATRuntimeException("Critical error occurred", t);
- } else {
- logger.error("[ERROR] " + msg + " " + t);
+ long instCnt = -1;
+ try {
+ instCnt = ThreadHandler.getInstructionCount(currentThread().getId());
+ } catch (Exception e) {
+ logger.error("Error while getting instruction count");
+ }
+ msg = "[SWAT Exception]: " + msg + " (at instruction: " + instCnt + ")";
+ logException(msg, t);
+ logger.error(msg);
+ logger.error("Preparing to halt execution due to error...");
+ try {
+ if (ThreadHandler.hasThreadContext(currentThread().getId())) {
+ ThreadHandler.logStats(currentThread().getId());
+ }
+ ThreadHandler.logStats(-1);
+ } catch (Exception e) {
+ logger.error("Error while logging stats");
+ }
+ logger.error("Halting...");
+ if (!config.isLogShadowStateToConsole()) {
+ logger.info("Flushing loggers...");
+ try {
+ long id = Thread.currentThread().getId();
+ Logger shadowStateLogger = ThreadHandler.getShadowStateLogger(id);
+ ((FileAppender)((AsyncAppender) shadowStateLogger
+ .getAppender("ASYNC_FILE"))
+ .getAppender("FILE")).getOutputStream().flush();
+ } catch (Exception e) {
+ logger.error("Error while flushing loggers", e);
+ }
}
+ Runtime.getRuntime().halt(-1);
+
}
-}
-/** SWATRuntimeException to encapsulate exceptions that lead to application termination. */
-class SWATRuntimeException extends RuntimeException {
- public SWATRuntimeException(String message, Throwable cause) {
- super(message, cause);
+ public void logException(String msg, Throwable t){
+ logger.error(msg, t);
+ long threadId = currentThread().getId();
+ String executionStage;
+ if(ThreadHandler.hasThreadContext(threadId)){
+ try {
+ executionStage = ThreadHandler.getCurrentInstruction(threadId).toString();
+ } catch (Exception e) {
+ logger.error("Error while getting current instruction", e);
+ executionStage = "Unknown";
+ }
+ } else {
+ executionStage = "Main Thread";
+ threadId = -1;
+ }
+
+ // Record the error
+ ErrorRecord errorRecord = new ErrorRecord(msg, t.getClass().getSimpleName(),
+ Arrays.toString(t.getStackTrace()), t.getMessage(), executionStage);
+ try{
+ ThreadHandler.recordException(threadId, errorRecord);
+ } catch (Exception e) {
+ logger.error("Error while recording exception", e);
+ }
}
+
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/PrintBox.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/PrintBox.java
index 3d7352a..c81f863 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/common/PrintBox.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/PrintBox.java
@@ -115,7 +115,11 @@ private String assemble() {
boxBuilder.append("-".repeat(Math.max(0, this.boxSize)));
boxBuilder.append("+\n");
- return boxBuilder.toString();
+ String assembledString = boxBuilder.toString();
+ boxBuilder.setLength(0);
+ msgs.clear();
+
+ return assembledString;
}
/**
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/Util.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/Util.java
new file mode 100644
index 0000000..db77b9a
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/Util.java
@@ -0,0 +1,413 @@
+package de.uzl.its.swat.common;
+
+import ch.qos.logback.classic.Logger;
+import de.uzl.its.swat.common.exceptions.*;
+import de.uzl.its.swat.common.logging.GlobalLogger;
+import de.uzl.its.swat.config.Config;
+import de.uzl.its.swat.instrument.TransformerType;
+import de.uzl.its.swat.symbolic.value.Value;
+import de.uzl.its.swat.symbolic.value.ValueFactory;
+import de.uzl.its.swat.symbolic.value.primitive.numeric.floatingpoint.DoubleValue;
+import de.uzl.its.swat.symbolic.value.primitive.numeric.floatingpoint.FloatValue;
+import de.uzl.its.swat.symbolic.value.primitive.numeric.integral.*;
+import de.uzl.its.swat.symbolic.value.reference.ObjectValue;
+import de.uzl.its.swat.symbolic.value.reference.lang.*;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.regex.Pattern;
+
+import de.uzl.its.swat.thread.ThreadHandler;
+import org.objectweb.asm.Type;
+
+import javax.annotation.Nullable;
+
+import static java.lang.Thread.currentThread;
+
+public class Util {
+
+ public static final String DIVIDER = "-".repeat(80);
+ public static final String FIELD_DIVIDER = "#";
+ public static final String METHOD_DIVIDER = ":";
+ private static final Config config = Config.instance();
+ private static final Logger logger = GlobalLogger.getSymbolicExecutionLogger();
+
+ private static final String[] includeList = config.getInstrumentationScope();
+
+ private static final String[] excludeList = config.getInstrumentationExcludePackages();
+
+
+ private static final String[] symbolicScope = config.getSymbolicScope().length > 0 ?
+ config.getSymbolicScope() : config.getInstrumentationScope();
+
+ private static final HashMap If the include packages are set, only classes in those packages will be instrumented. If
+ * the exclude packages are set, classes in those packages will not be instrumented. If a class
+ * matches both an include and an exclude package, the more specific match (longer prefix) will
+ * take precedence.
+ *
+ * @param cname the name of the class
+ * @return true if the class should be instrumented, false otherwise
+ */
+ public static boolean shouldInstrument(String cname) {
+ cname = formatClassName(cname);
+ // Special case for SV-Comp
+ if (cname.equals("de/uzl/its/swat/instrument/svcomp/Verifier")
+ && config.getInstrumentationTransformer().equals(TransformerType.SV_COMP)) {
+ logger.trace("Instrumenting SV-Comp Verifier class");
+ return true;
+ }
+
+ if (isInstrumentedUtilClass(cname)) {
+ logger.trace("Instrumenting UtilInstrumented class");
+ return true;
+ }
+
+ if (shouldInstrumentCache.containsKey(cname)) {
+ return shouldInstrumentCache.get(cname);
+ }
+ int longestInclude = includeList.length > 0 ? longestPrefix(includeList, cname) : -1;
+ int longestExclude = excludeList.length > 0 ? longestPrefix(excludeList, cname) : -1;
+ boolean verdict = includeList.length > 0 ? longestInclude > longestExclude : longestExclude == -1;
+ if (verdict) {
+ logger.trace("Instrumenting '{}': Included prefix = {}, Excluded prefix = {}", cname, longestInclude,
+ longestExclude);
+ }
+ // logger.trace("Decision to instrument '{}': Included prefix = {}, Excluded prefix = {}, Verdict = {}",
+ // cname, longestInclude, longestExclude, verdict);
+
+ shouldInstrumentCache.put(cname, verdict);
+ return verdict;
+ }
+
+ public static boolean isInstrumentedUtilClass(String cname) {
+ cname = formatClassName(cname);
+ return cname.equals("de/uzl/its/swat/common/UtilInstrumented");
+ }
+
+ public static boolean ignoreMethod(String methodName) {
+ return methodName.equals("$jacocoInit");
+ }
+
+ public static boolean isInSymbolicScope(String cname) {
+ cname = formatClassName(cname);
+ int longestInclude = symbolicScope.length > 0 ? longestPrefix(symbolicScope, cname) : -1;
+ int longestExclude = excludeList.length > 0 ? longestPrefix(excludeList, cname) : -1;
+ boolean verdict = symbolicScope.length > 0 ? longestInclude > longestExclude : longestExclude == -1;
+ return verdict;
+ }
+
+ public static boolean useCheckClassAdapterForClass(String cname) {
+
+ if (Config.instance().getCheckClassAdapterClass().equals("*")) {
+ return true;
+ } else {
+ return formatClassName(cname).equals(Config.instance().getCheckClassAdapterClass());
+ }
+ }
+
+ private static int longestPrefix(String[] arr, String str) {
+ return Arrays.stream(arr).filter(str::startsWith).mapToInt(String::length).max().orElse(-1);
+ }
+
+
+ public static Field[] getDeclaredFields(Class clazz)
+ throws ThreadAlreadyEnabledException, ThreadAlreadyDisabledException, NoThreadContextException {
+ // Get fields, this might cause a class load, which might trigger an instrumented class
+ // loader. Hence, we have to disable the tracking during the load.
+ ThreadHandler.disableThreadContext(currentThread().getId()); // Todo is that needed?
+ Field[] fields = clazz.getDeclaredFields();
+ ThreadHandler.enableThreadContext(currentThread().getId());
+ return fields;
+ }
+
+ public static Class getSuperclass(Class clazz)
+ throws ThreadAlreadyEnabledException, ThreadAlreadyDisabledException, NoThreadContextException {
+ ThreadHandler.disableThreadContext(currentThread().getId()); // Todo is that needed?
+ Class superclass = clazz.getSuperclass();
+ ThreadHandler.enableThreadContext(currentThread().getId());
+ return superclass;
+ }
+
+ public static Class[] getInterfaces(Class clazz)
+ throws ThreadAlreadyEnabledException, ThreadAlreadyDisabledException, NoThreadContextException {
+ ThreadHandler.disableThreadContext(currentThread().getId()); // Todo is that needed?
+ Class[] interfaces = clazz.getInterfaces();
+ ThreadHandler.enableThreadContext(currentThread().getId());
+ return interfaces;
+ }
+
+
+ private static void checkClassName(String className) {
+ SWATAssert.check(!className.contains(";") ||!className.contains("(") || !className.contains(")") || !className.contains("L"),
+ "Class name should not contain ';' or brackets");
+ }
+ /**
+ * Formats a class name to the format used in the JVM.
+ * @param className the class name
+ * @return the formatted class name
+ */
+ public static String formatClassName(String className) {
+ checkClassName(className);
+ if(className.contains(".")) {
+ return className.replace(".", "/");
+ }
+ return className;
+ }
+
+ public static String formatFieldName(String className, String fieldName) {
+ checkClassName(className);
+ return className.replace("/", ".") + FIELD_DIVIDER + fieldName;
+ }
+
+ public static String formatMethodName(String className, String methodName, String desc) {
+ return formatClassName(className) + METHOD_DIVIDER + methodName + METHOD_DIVIDER + desc;
+ }
+
+ public static String extractMethodName(String methodName) {
+ String [] mNameParts = methodName.split(METHOD_DIVIDER);
+ SWATAssert.check(mNameParts.length == 3, "Method divider should be present twice: cname
+ * We (need) to use a custom assertion class because Java's built-in assert statement does not work reliably in the
+ * classes used during instrumentation even when -esa (enable system assertions) is set.
+ */
+public class SWATAssert {
+ //
+ @Setter
+ private static boolean enabled = Config.instance().isUseAssertions();
+
+ private static final Logger logger = GlobalLogger.getSymbolicExecutionLogger();
+
+ private SWATAssert() {
+ // Prevent instantiation
+ }
+
+ /**
+ * Checks the given condition and throws an AssertionError with the given message if the condition is false.
+ * This method is similar to Java's built-in assert keyword and should be used in cases where execution is expected
+ * to be able to continue with some recoverable loss. In cases that are critical to the application, consider using
+ * enforce instead.
+ *
+ * @param condition The condition to check
+ * @param message The message to include in the AssertionError, including placeholders {}
+ * @param args The arguments to replace the placeholders in the message
+ */
+
+ public static void check(boolean condition, String message, Object... args) {
+ if (condition) {
+ return;
+ }
+ String formattedMessage = "[SWAT Assertion]: " + String.format(message.replace("{}", "%s"), args);
+ AssertionError assertionError = new AssertionError(formattedMessage);
+ if (enabled) {
+ new ErrorHandler().handleException(formattedMessage, assertionError);
+ } else {
+ new ErrorHandler().logException(formattedMessage, assertionError);
+ }
+ }
+
+ /**
+ * Analogous to check, but always throws an AssertionError. Should be used in cases where execution cannot continue.
+ *
+ * @param condition The condition to check
+ * @param message The message to include in the AssertionError, including placeholders {}
+ * @param args The arguments to replace the placeholders in the message
+ */
+ public static void enforce(boolean condition, String message, Object... args) {
+ if (condition) {
+ return;
+ }
+ String formattedMessage = "[SWAT Assertion]: " + String.format(message.replace("{}", "%s"), args);
+ AssertionError assertionError = new AssertionError(formattedMessage);
+ new ErrorHandler().handleException(formattedMessage, assertionError);
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/SWATException.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/SWATException.java
new file mode 100644
index 0000000..01d31e6
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/SWATException.java
@@ -0,0 +1,14 @@
+package de.uzl.its.swat.common.exceptions;
+
+/**
+ * A runtime exception used by SWAT to signal fatal errors
+ */
+public class SWATException extends Exception {
+ public SWATException(String message) {
+ super(message);
+ }
+
+ public SWATException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
\ No newline at end of file
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/SymbolicInstructionException.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/SymbolicInstructionException.java
new file mode 100644
index 0000000..8b3866e
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/SymbolicInstructionException.java
@@ -0,0 +1,13 @@
+package de.uzl.its.swat.common.exceptions;
+
+import de.uzl.its.swat.symbolic.instruction.Instruction;
+
+public class SymbolicInstructionException extends Exception{
+ public SymbolicInstructionException(Instruction inst, String message) {
+ super("Error during symbolic execution of instruction " + inst + " --> " + message);
+ }
+ public SymbolicInstructionException(Instruction inst, Throwable t) {
+ super("Error during symbolic execution of instruction " + inst, t);
+ }
+
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ThreadAlreadyDisabledException.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ThreadAlreadyDisabledException.java
new file mode 100644
index 0000000..12679db
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ThreadAlreadyDisabledException.java
@@ -0,0 +1,7 @@
+package de.uzl.its.swat.common.exceptions;
+
+public class ThreadAlreadyDisabledException extends Exception {
+ public ThreadAlreadyDisabledException(long threadId) {
+ super("Thread already disabled: " + threadId);
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ThreadAlreadyEnabledException.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ThreadAlreadyEnabledException.java
new file mode 100644
index 0000000..8bd0e1b
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ThreadAlreadyEnabledException.java
@@ -0,0 +1,7 @@
+package de.uzl.its.swat.common.exceptions;
+
+public class ThreadAlreadyEnabledException extends Exception {
+ public ThreadAlreadyEnabledException(long threadId) {
+ super("Thread already enabled: " + threadId);
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/TypeException.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/TypeException.java
new file mode 100644
index 0000000..1fc0c09
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/TypeException.java
@@ -0,0 +1,17 @@
+package de.uzl.its.swat.common.exceptions;
+
+import de.uzl.its.swat.instrument.DataType;
+import de.uzl.its.swat.symbolic.value.ValueType;
+
+public class TypeException extends Exception {
+ public TypeException(char type) {
+ super("Unexpected type: " + type);
+ }
+ public TypeException(DataType type) {
+ super("Unexpected type: " + type);
+ }
+
+ public TypeException(ValueType type) {
+ super("Unexpected type: " + type);
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ValueConversionException.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ValueConversionException.java
new file mode 100644
index 0000000..7c80b73
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/exceptions/ValueConversionException.java
@@ -0,0 +1,8 @@
+package de.uzl.its.swat.common.exceptions;
+
+/** Exception class used when shadow values cannot be converted to the requested type. */
+public class ValueConversionException extends Exception {
+ public ValueConversionException(String message) {
+ super(message);
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/logging/GlobalLogger.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/logging/GlobalLogger.java
new file mode 100644
index 0000000..b7c37fa
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/logging/GlobalLogger.java
@@ -0,0 +1,73 @@
+package de.uzl.its.swat.common.logging;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import de.uzl.its.swat.config.Config;
+
+// ToDo: Not thread-safe yet
+public class GlobalLogger {
+
+ private static Logger solutionLogger;
+ private static Logger symbolicExecutionLogger;
+ private static Logger errorLogger;
+
+
+ public static Logger getSymbolicExecutionLogger() {
+
+ if (symbolicExecutionLogger == null) {
+
+ boolean logToConsole = Config.instance().isLogToConsole();
+ Level logLevel =
+ Config.instance().isDisableSymbolicExecutionLogging()
+ ? Level.OFF
+ : Config.instance().getLoggingLevel();
+
+ symbolicExecutionLogger =
+ LoggerUtils.createGlobalLogger(
+ "symbolic-execution",
+ null,
+ logToConsole,
+ logLevel);
+
+ LoggerUtils.addErrorOnlyFileAppender(symbolicExecutionLogger, "errors.log", null);
+ }
+
+ return symbolicExecutionLogger;
+ }
+
+ public static Logger getErrorLogger() {
+
+ if (errorLogger == null) {
+
+ errorLogger =
+ LoggerUtils.createGlobalLogger(
+ "error",
+ null,
+ true,
+ Level.ERROR);
+
+ LoggerUtils.addErrorOnlyFileAppender(errorLogger, "errors.log", null);
+ }
+
+ return errorLogger;
+ }
+
+ public static Logger getSolutionLogger() {
+
+
+ if (solutionLogger == null) {
+
+ boolean logToConsole = Config.instance().isLogToConsole();
+ solutionLogger =
+ LoggerUtils.createGlobalLogger(
+ "solution",
+ null,
+ logToConsole,
+ Config.instance().getLoggingLevel());
+
+ LoggerUtils.addErrorOnlyFileAppender(solutionLogger, "errors.log", null);
+ }
+
+ return solutionLogger;
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/common/logging/LoggerUtils.java b/symbolic-executor/src/main/java/de/uzl/its/swat/common/logging/LoggerUtils.java
new file mode 100644
index 0000000..c2d93a5
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/common/logging/LoggerUtils.java
@@ -0,0 +1,192 @@
+package de.uzl.its.swat.common.logging;
+
+import ch.qos.logback.classic.AsyncAppender;
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
+import ch.qos.logback.classic.filter.ThresholdFilter;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.ConsoleAppender;
+import ch.qos.logback.core.FileAppender;
+import de.uzl.its.swat.common.exceptions.SWATAssert;
+import de.uzl.its.swat.config.Config;
+import org.slf4j.LoggerFactory;
+
+public class LoggerUtils {
+ private static final String fileAppenderName = "FILE";
+ private static final String consoleAppenderName = "CONSOLE";
+ private static final String errorFileAppenderName = "ERROR_FILE";
+
+ public static Logger createAsyncFileLogger(String baseName,
+ String dir,
+ Level level) {
+
+ baseName = sanitizeEndpointName(baseName);
+ String uniqueSuffix = getUniqueSuffix(baseName, dir);
+ baseName = baseName + uniqueSuffix;
+ Logger logger = (Logger) LoggerFactory.getLogger("shadow-state-logger-" + baseName);
+
+ FileAppender All Coverage subclasses have package scope constructors, such that no class outside the
+ * package can create a Coverage object.
+ *
+ * @return Coverage
+ */
+ public InstrCoverage getCoverage(CoverageType type) {
+ return switch (type) {
+ case HASH -> new SimpleHashSetInstrCoverage();
+ case TRACE -> new ExecutionTrace();
+ case NONE -> null;
+ };
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/CoverageRequest.java b/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/CoverageRequest.java
new file mode 100644
index 0000000..a2c6dcd
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/CoverageRequest.java
@@ -0,0 +1,57 @@
+package de.uzl.its.swat.coverage;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import de.uzl.its.swat.config.Config;
+import de.uzl.its.swat.request.Request;
+import de.uzl.its.swat.symbolic.trace.dto.CoverageDTO;
+
+public class CoverageRequest extends Request {
+
+ private static final Config config = Config.instance();
+
+ public static void sendCoverage(String requestBody, int endpointID, int traceID) {
+ if (requestBody != null) {
+
+ String host = config.getExplorerHost();
+ int port = config.getExplorerPort();
+ String path = config.getInstrCoveragePath();
+ try {
+ send(host, port, path, endpointID, traceID, requestBody);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public static void sendTotalBranches() {
+
+ String host = config.getExplorerHost();
+ int port = config.getExplorerPort();
+ String path = config.getBranchCoveragePath();
+ try {
+ send(
+ host,
+ port,
+ path,
+ -1,
+ -1,
+ buildBranchCoverageRequestBody(
+ new CoverageDTO(
+ BranchCoverage.getVisitedBranches().stream().toList(),
+ BranchCoverage.getTotalBranches().size())));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static String buildBranchCoverageRequestBody(Object payload)
+ throws JsonProcessingException {
+
+ ObjectMapper objectMapper = new ObjectMapper();
+ objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
+ return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(payload);
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/CoverageType.java b/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/CoverageType.java
new file mode 100644
index 0000000..e278710
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/CoverageType.java
@@ -0,0 +1,7 @@
+package de.uzl.its.swat.coverage;
+
+public enum CoverageType {
+ HASH,
+ TRACE,
+ NONE
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/ExecutionTrace.java b/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/ExecutionTrace.java
new file mode 100644
index 0000000..1d7271a
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/coverage/ExecutionTrace.java
@@ -0,0 +1,33 @@
+package de.uzl.its.swat.coverage;
+
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class ExecutionTrace extends InstrCoverage {
+
+ private final ArrayList
+ * When a field is visited, if an annotation matching {@code @Symbolic} is found, the field's
+ * name, descriptor, and whether it is static are recorded into a shared list.
+ *
+ *
+ * This transformer uses the {@link AnnotationClassAdapter} to modify classes whose internal
+ * name matches the instrumentation criteria (as determined by {@link Util#shouldInstrument(String)}).
+ * Instrumented classes are logged and added to the list of instrumented classes.
+ *
+ * The transformer uses {@link AnnotationClassAdapter} to modify the class bytecode. It also
+ * verifies the correctness of the modified class if configured to do so.
+ *
+ * Static fields are not instrumented.
+ *
+ * Retrieves the formatted class name (e.g., "java/lang/String") corresponding to a given integer
+ * index. This is the inverse operation of {@link #getClassIndex(String)}.
+ *
+ * This package provides classes and templates for managing metadata about classes and their fields,
+ * both at instrumentation time and at runtime.
+ *
+ * The central component is {@link de.uzl.its.swat.metadata.ClassDepot}, which acts as a registry to track each class and
+ * its fields. It uses two different template types:
+ * The called method however receives the unpackaged parameters. Since the unpacking code is
+ * not instrumented, we add a helper method to do the unpacking for us.
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void UNPACK_INVOKE_PARAMETER(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("UNPACK_INVOKE_PARAMETER {}", iid);
+}
+
+
+ @SuppressWarnings("unused")
+ public static void SET_FIELD_REFLECTION(String owner, String name, String desc, String reflectFieldName, String reflectObjectOwner, boolean isWideOperand, int modifiers, long iid, long invokeId) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("SET_FIELD_REFLECTION {}", iid);
+}
+
+
+ @SuppressWarnings("unused")
+ public static void GET_FIELD_REFLECTION(String owner, String name, String desc, String reflectFieldName, String reflectObjectOwner, int modifiers, long iid, long invokeId) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GET_FIELD_REFLECTION {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ANEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ANEWARRAY}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type type of the array to create.
+ */
+ @SuppressWarnings("unused")
+ public static void ANEWARRAY(long iid, String type) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ANEWARRAY {}", iid);
+}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CHECKCAST instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CHECKCAST}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type to check against
+ */
+ @SuppressWarnings("unused")
+ public static void CHECKCAST(long iid, String type) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("CHECKCAST {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INSTANCEOF instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INSTANCEOF}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type to check against
+ */
+ @SuppressWarnings("unused")
+ public static void INSTANCEOF(long iid, String type) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("INSTANCEOF {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BIPUSH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BIPUSH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param value the value to be pushed.
+ */
+ @SuppressWarnings("unused")
+ public static void BIPUSH(long iid, int value) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("BIPUSH {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SIPUSH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SIPUSH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param value the value to be pushed.
+ */
+ @SuppressWarnings("unused")
+ public static void SIPUSH(long iid, int value) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("SIPUSH {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NEWARRAY}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param atype the type of the array to be created
+ */
+ @SuppressWarnings("unused")
+ public static void NEWARRAY(long iid, int atype) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("NEWARRAY {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ILOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ILOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ILOAD(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ILOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void LLOAD(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LLOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void FLOAD(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FLOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void DLOAD(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DLOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ALOAD(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ISTORE(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ISTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void LSTORE(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LSTORE {}", iid);
+}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void FSTORE(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FSTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void DSTORE(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DSTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ASTORE(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the RET instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.RET}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index to the return address
+ */
+ @SuppressWarnings("unused")
+ public static void RET(long iid, int var) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("RET {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NOP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NOP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void NOP(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("NOP {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ACONST_NULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ACONST_NULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ACONST_NULL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ACONST_NULL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_M1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_M1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_M1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_M1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_0(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_0 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_2(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_2 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_3 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_3}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_3(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_3 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_4 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_4}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_4(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_4 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_5 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_5}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_5(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ICONST_5 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCONST_0(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LCONST_0 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCONST_1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LCONST_1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_0(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FCONST_0 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FCONST_1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_2(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FCONST_2 {}", iid);
+}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCONST_0(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DCONST_0 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCONST_1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DCONST_1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the AALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.AALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void AALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("AALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void BALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("BALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void CALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("CALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SALOAD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("SALOAD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the AASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.AASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void AASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("AASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void BASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("BASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void CASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("CASTORE {}", iid);
+}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SASTORE(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("SASTORE {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the POP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.POP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void POP(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("POP {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the POP2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.POP2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void POP2(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("POP2 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DUP {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP_X1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP_X1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP_X1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DUP_X1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP_X2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP_X2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP_X2(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DUP_X2 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DUP2 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2_X1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2_X1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2_X1(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DUP2_X1 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2_X2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2_X2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2_X2(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DUP2_X2 {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SWAP instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SWAP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SWAP(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("SWAP {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IADD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IADD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LADD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LADD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FADD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FADD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DADD(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DADD {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISUB(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ISUB {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSUB(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LSUB {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FSUB(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FSUB {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DSUB(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DSUB {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IMUL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IMUL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LMUL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LMUL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FMUL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FMUL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DMUL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DMUL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IDIV(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IDIV {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LDIV(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LDIV {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FDIV(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FDIV {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DDIV(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DDIV {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IREM(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IREM {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LREM(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LREM {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FREM(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FREM {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DREM(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DREM {}", iid);
+}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void INEG(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("INEG {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LNEG(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LNEG {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FNEG(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FNEG {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DNEG(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DNEG {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISHL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISHL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISHL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ISHL {}", iid);
+}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSHL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSHL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSHL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LSHL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISHR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ISHR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSHR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LSHR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IUSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IUSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IUSHR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IUSHR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LUSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LUSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LUSHR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LUSHR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IAND instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IAND}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IAND(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IAND {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LAND instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LAND}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LAND(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LAND {}", iid);
+}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IOR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IOR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IOR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LOR {}", iid);
+}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IXOR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IXOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IXOR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IXOR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LXOR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LXOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LXOR(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LXOR {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2L(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("I2L {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2F(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("I2F {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2D(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("I2D {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2I(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("L2I {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2F(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("L2F {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2D(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("L2D {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2I(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("F2I {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2L(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("F2L {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2D(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("F2D {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2I(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("D2I {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2L(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("D2L {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2F(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("D2F {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2B instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2B}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2B(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("I2B {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2C instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2C}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2C(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("I2C {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2S instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2S}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2S(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("I2S {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCMP instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCMP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCMP(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LCMP {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCMPL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCMPL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCMPL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FCMPL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCMPG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCMPG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCMPG(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FCMPG {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCMPL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCMPL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCMPL(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DCMPL {}", iid);
+}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCMPG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCMPG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCMPG(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DCMPG {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IRETURN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("IRETURN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LRETURN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LRETURN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FRETURN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("FRETURN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DRETURN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("DRETURN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ARETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ARETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ARETURN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ARETURN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the RETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.RETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void RETURN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("RETURN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ARRAYLENGTH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ARRAYLENGTH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ARRAYLENGTH(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ARRAYLENGTH {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ATHROW instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ATHROW}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ATHROW(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("ATHROW {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MONITORENTER instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MONITORENTER}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MONITORENTER(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("MONITORENTER {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MONITOREXIT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MONITOREXIT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MONITOREXIT(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("MONITOREXIT {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_double instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_double}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_double(double v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_double {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_long instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_long}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_long(long v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_long {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_Object instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_Object}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_Object(Object v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_Object {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_boolean instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_boolean}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_boolean(boolean v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_boolean {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_byte instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_byte}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_byte(byte v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_byte {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_char instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_char}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_char(char v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_char {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_float instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_float}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_float(float v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_float {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_int instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_int}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_int(int v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_int {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_short instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_short}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_short(short v, long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_short {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_void instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_void}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_void(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("GETVALUE_void {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEMETHOD_EXCEPTION instruction is executed
+ * in an instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEMETHOD_EXCEPTION}. The instruction is handled in
+ * the {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEMETHOD_EXCEPTION(long iid, long invokeId) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("INVOKEMETHOD_EXCEPTION {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEMETHOD_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEMETHOD_END}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEMETHOD_END(long iid, long invokeId) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("INVOKEMETHOD_END {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKECLINIT_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKECLINIT_END}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKECLINIT_END(long iid, long invokeId) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("INVOKECLINIT_END {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SPECIAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SPECIAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param i marker used in symbolic interpreter for example for branch detection.
+ */
+ @SuppressWarnings("unused")
+ public static void SPECIAL(long iid, int i) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("SPECIAL {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MAKE_SYMBOLIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * MAKE_SYMBOLIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitMAKE_SYMBOLIC(MAKE_SYMBOLIC)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MAKE_SYMBOLIC(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("MAKE_SYMBOLIC {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOP_BEGIN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * LOOP_BEGIN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitLOOP_BEGIN(LOOP_BEGIN)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOP_BEGIN(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LOOP_BEGIN {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOP_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * LOOP_END}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitLOOP_END(LOOP_END)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOP_END(long iid) throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("LOOP_END {}", iid);
+}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the flush instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the visitor method in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor}.
+ */
+ @SuppressWarnings("unused")
+ public static void flush() throws NoThreadContextException {
+ Logger logger = ThreadHandler.getShadowStateLogger(-1);
+ logger.info("flush");
+}
+
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/dispatcher/NopDispatcher.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/dispatcher/NopDispatcher.java
new file mode 100644
index 0000000..69f1fb1
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/dispatcher/NopDispatcher.java
@@ -0,0 +1,3044 @@
+package de.uzl.its.swat.symbolic.dispatcher;
+
+import de.uzl.its.swat.symbolic.SymbolicInstructionVisitor;
+import de.uzl.its.swat.symbolic.instruction.LOOP_BEGIN;
+import de.uzl.its.swat.symbolic.instruction.LOOP_END;
+import de.uzl.its.swat.symbolic.instruction.MAKE_SYMBOLIC;
+
+public final class NopDispatcher {
+
+ private NopDispatcher() {}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_int instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_int}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, int c) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_long instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_long}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load.
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, long c) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_float instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_float}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load.
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, float c) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_double instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_double}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load.
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, double c) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_String instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_String}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, String c) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_Object instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_Object}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c the address of the object that's loaded
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, Object c) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IINC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IINC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var the local variable index.
+ * @param increment the increment amount.
+ */
+ @SuppressWarnings("unused")
+ public static void IINC(long iid, int var, int increment) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MULTIANEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MULTIANEWARRAY}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param desc the descriptor of the array
+ * @param dims the number of dimensions
+ */
+ @SuppressWarnings("unused")
+ public static void MULTIANEWARRAY(long iid, String desc, int dims) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOKUPSWITCH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOOKUPSWITCH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param dflt beginning of the default handler block.
+ * @param keys the values of the keys.
+ * @param labels beginnings of the handler blocks.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOKUPSWITCH(long iid, int dflt, int[] keys, int[] labels) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the TABLESWITCH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.TABLESWITCH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param min min value.
+ * @param max max value.
+ * @param dflt beginning of the default handler block.
+ * @param labels beginnings of the handler blocks.
+ * @param values the conditions.
+ */
+ @SuppressWarnings("unused")
+ public static void TABLESWITCH(
+ long iid, int min, int max, int dflt, int[] labels, int[] values) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFEQ instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFEQ}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFEQ(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFNE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFNE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFNE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFLT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFLT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFLT(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFGE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFGE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFGE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFGT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFGT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFGT(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFLE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFLE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFLE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPEQ instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPEQ}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPEQ(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPNE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPNE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPNE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPLT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPLT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPLT(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPGE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPGE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPGE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPGT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPGT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPGT(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPLE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPLE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPLE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ACMPEQ instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ACMPEQ}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ACMPEQ(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ACMPNE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ACMPNE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ACMPNE(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GOTO instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GOTO}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void GOTO(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the JSR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.JSR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void JSR(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFNULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFNULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFNULL(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFNONNULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFNONNULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFNONNULL(long iid, int label) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEVIRTUAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEVIRTUAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEVIRTUAL(
+ long iid, long invokeId, String owner, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKESPECIAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKESPECIAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKESPECIAL(
+ long iid, long invokeId, String owner, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEDYNAMIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEDYNAMIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEDYNAMIC(
+ long iid, long invokeId, String owner, String name, String desc, String lambda) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKESTATIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKESTATIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKESTATIC(
+ long iid, long invokeId, String owner, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEINTERFACE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEINTERFACE}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEINTERFACE(
+ long iid, long invokeId, String owner, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETSTATIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETSTATIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void GETSTATIC(long iid, int cIdx, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the PUTSTATIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.PUTSTATIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void PUTSTATIC(long iid, int cIdx, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETFIELD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETFIELD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void GETFIELD(long iid, int cIdx, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the PUTFIELD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.PUTFIELD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void PUTFIELD(long iid, int cIdx, String name, String desc) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NEW instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NEW}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type of the object to be created
+ * @param cIdx the class index
+ */
+ @SuppressWarnings("unused")
+ public static void NEW(long iid, String type, int cIdx) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CLINIT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CLINIT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx the class index
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void CLINIT(long iid, int cIdx, long invokeId) {}
+
+
+ /**
+ * When a method is invoked with reflection, the jvm will compile code that adds all parameters
+ * to an array and adds this array to the frame, instead of adding all parameters to the frame.
+ *
+ * The called method however receives the unpackaged parameters. Since the unpacking code is
+ * not instrumented, we add a helper method to do the unpacking for us.
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void UNPACK_INVOKE_PARAMETER(long iid) {}
+
+
+ @SuppressWarnings("unused")
+ public static void SET_FIELD_REFLECTION(String owner, String name, String desc, String reflectFieldName, String reflectObjectOwner, boolean isWideOperand, int modifiers, long iid, long invokeId) {}
+
+
+ @SuppressWarnings("unused")
+ public static void GET_FIELD_REFLECTION(String owner, String name, String desc, String reflectFieldName, String reflectObjectOwner, int modifiers, long iid, long invokeId) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ANEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ANEWARRAY}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type type of the array to create.
+ */
+ @SuppressWarnings("unused")
+ public static void ANEWARRAY(long iid, String type) {}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CHECKCAST instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CHECKCAST}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type to check against
+ */
+ @SuppressWarnings("unused")
+ public static void CHECKCAST(long iid, String type) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INSTANCEOF instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INSTANCEOF}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type to check against
+ */
+ @SuppressWarnings("unused")
+ public static void INSTANCEOF(long iid, String type) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BIPUSH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BIPUSH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param value the value to be pushed.
+ */
+ @SuppressWarnings("unused")
+ public static void BIPUSH(long iid, int value) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SIPUSH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SIPUSH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param value the value to be pushed.
+ */
+ @SuppressWarnings("unused")
+ public static void SIPUSH(long iid, int value) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NEWARRAY}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param atype the type of the array to be created
+ */
+ @SuppressWarnings("unused")
+ public static void NEWARRAY(long iid, int atype) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ILOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ILOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ILOAD(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void LLOAD(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void FLOAD(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void DLOAD(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ALOAD(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ISTORE(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void LSTORE(long iid, int var) {}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void FSTORE(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void DSTORE(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ASTORE(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the RET instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.RET}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index to the return address
+ */
+ @SuppressWarnings("unused")
+ public static void RET(long iid, int var) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NOP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NOP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void NOP(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ACONST_NULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ACONST_NULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ACONST_NULL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_M1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_M1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_M1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_0(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_2(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_3 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_3}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_3(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_4 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_4}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_4(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_5 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_5}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_5(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCONST_0(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCONST_1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_0(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_2(long iid) {}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCONST_0(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCONST_1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the AALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.AALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void AALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void BALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void CALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SALOAD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the AASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.AASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void AASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void BASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void CASTORE(long iid) {}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SASTORE(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the POP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.POP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void POP(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the POP2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.POP2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void POP2(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP_X1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP_X1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP_X1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP_X2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP_X2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP_X2(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2_X1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2_X1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2_X1(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2_X2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2_X2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2_X2(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SWAP instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SWAP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SWAP(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IADD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LADD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FADD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DADD(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISUB(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSUB(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FSUB(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DSUB(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IMUL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LMUL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FMUL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DMUL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IDIV(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LDIV(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FDIV(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DDIV(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IREM(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LREM(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FREM(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DREM(long iid) {}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void INEG(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LNEG(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FNEG(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DNEG(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISHL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISHL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISHL(long iid) {}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSHL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSHL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSHL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISHR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSHR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IUSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IUSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IUSHR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LUSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LUSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LUSHR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IAND instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IAND}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IAND(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LAND instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LAND}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LAND(long iid) {}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IOR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IOR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOR(long iid) {}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IXOR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IXOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IXOR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LXOR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LXOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LXOR(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2L(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2F(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2D(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2I(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2F(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2D(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2I(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2L(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2D(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2I(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2L(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2F(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2B instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2B}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2B(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2C instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2C}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2C(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2S instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2S}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2S(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCMP instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCMP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCMP(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCMPL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCMPL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCMPL(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCMPG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCMPG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCMPG(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCMPL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCMPL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCMPL(long iid) {}
+
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCMPG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCMPG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCMPG(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IRETURN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LRETURN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FRETURN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DRETURN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ARETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ARETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ARETURN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the RETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.RETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void RETURN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ARRAYLENGTH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ARRAYLENGTH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ARRAYLENGTH(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ATHROW instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ATHROW}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ATHROW(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MONITORENTER instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MONITORENTER}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MONITORENTER(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MONITOREXIT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MONITOREXIT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MONITOREXIT(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_double instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_double}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_double(double v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_long instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_long}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_long(long v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_Object instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_Object}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_Object(Object v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_boolean instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_boolean}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_boolean(boolean v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_byte instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_byte}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_byte(byte v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_char instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_char}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_char(char v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_float instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_float}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_float(float v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_int instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_int}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_int(int v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_short instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_short}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_short(short v, long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_void instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_void}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_void(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEMETHOD_EXCEPTION instruction is executed
+ * in an instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEMETHOD_EXCEPTION}. The instruction is handled in
+ * the {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEMETHOD_EXCEPTION(long iid, long invokeId) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEMETHOD_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEMETHOD_END}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEMETHOD_END(long iid, long invokeId) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKECLINIT_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKECLINIT_END}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKECLINIT_END(long iid, long invokeId) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SPECIAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SPECIAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param i marker used in symbolic interpreter for example for branch detection.
+ */
+ @SuppressWarnings("unused")
+ public static void SPECIAL(long iid, int i) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MAKE_SYMBOLIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * MAKE_SYMBOLIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitMAKE_SYMBOLIC(MAKE_SYMBOLIC)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MAKE_SYMBOLIC(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOP_BEGIN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * LOOP_BEGIN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitLOOP_BEGIN(LOOP_BEGIN)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOP_BEGIN(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOP_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * LOOP_END}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitLOOP_END(LOOP_END)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOP_END(long iid) {}
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the flush instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the visitor method in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor}.
+ */
+ @SuppressWarnings("unused")
+ public static void flush() {}
+
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/dispatcher/SymbolicInstructionDispatcher.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/dispatcher/SymbolicInstructionDispatcher.java
new file mode 100644
index 0000000..cf3d25a
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/dispatcher/SymbolicInstructionDispatcher.java
@@ -0,0 +1,3598 @@
+package de.uzl.its.swat.symbolic.dispatcher;
+
+import de.uzl.its.swat.symbolic.SymbolicInstructionVisitor;
+import de.uzl.its.swat.symbolic.instruction.LOOP_BEGIN;
+import de.uzl.its.swat.symbolic.instruction.LOOP_END;
+import de.uzl.its.swat.symbolic.instruction.MAKE_SYMBOLIC;
+import de.uzl.its.swat.symbolic.processor.InstructionProcessor;
+import de.uzl.its.swat.thread.ThreadHandler;
+
+public final class SymbolicInstructionDispatcher {
+
+ private SymbolicInstructionDispatcher() {}
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_int instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_int}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, int c) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDC(iid, c);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_long instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_long}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load.
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, long c) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDC(iid, c);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_float instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_float}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load.
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, float c) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDC(iid, c);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_double instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_double}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load.
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, double c) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDC(iid, c);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_String instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_String}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c The constant to load
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, String c) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDC(iid, c);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDC_Object instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDC_Object}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param c the address of the object that's loaded
+ */
+ @SuppressWarnings("unused")
+ public static void LDC(long iid, Object c) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDC(iid, c);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IINC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IINC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var the local variable index.
+ * @param increment the increment amount.
+ */
+ @SuppressWarnings("unused")
+ public static void IINC(long iid, int var, int increment) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IINC(iid, var, increment);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MULTIANEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MULTIANEWARRAY}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param desc the descriptor of the array
+ * @param dims the number of dimensions
+ */
+ @SuppressWarnings("unused")
+ public static void MULTIANEWARRAY(long iid, String desc, int dims) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.MULTIANEWARRAY(iid, desc, dims);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOKUPSWITCH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOOKUPSWITCH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param dflt beginning of the default handler block.
+ * @param keys the values of the keys.
+ * @param labels beginnings of the handler blocks.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOKUPSWITCH(long iid, int dflt, int[] keys, int[] labels) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LOOKUPSWITCH(iid, dflt, keys, labels);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the TABLESWITCH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.TABLESWITCH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param min min value.
+ * @param max max value.
+ * @param dflt beginning of the default handler block.
+ * @param labels beginnings of the handler blocks.
+ * @param values the conditions.
+ */
+ @SuppressWarnings("unused")
+ public static void TABLESWITCH(
+ long iid, int min, int max, int dflt, int[] labels, int[] values) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.TABLESWITCH(iid, min, max, dflt, labels, values);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFEQ instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFEQ}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFEQ(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFEQ(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFNE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFNE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFNE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFNE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFLT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFLT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFLT(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFLT(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFGE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFGE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFGE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFGE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFGT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFGT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFGT(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFGT(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFLE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFLE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFLE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFLE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPEQ instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPEQ}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPEQ(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ICMPEQ(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPNE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPNE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPNE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ICMPNE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPLT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPLT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPLT(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ICMPLT(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPGE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPGE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPGE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ICMPGE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPGT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPGT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPGT(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ICMPGT(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ICMPLE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ICMPLE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ICMPLE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ICMPLE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ACMPEQ instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ACMPEQ}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ACMPEQ(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ACMPEQ(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IF_ACMPNE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IF_ACMPNE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IF_ACMPNE(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IF_ACMPNE(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GOTO instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GOTO}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void GOTO(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GOTO(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the JSR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.JSR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void JSR(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.JSR(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFNULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFNULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFNULL(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFNULL(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IFNONNULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IFNONNULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param label the jump destination
+ */
+ @SuppressWarnings("unused")
+ public static void IFNONNULL(long iid, int label) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IFNONNULL(iid, label);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEVIRTUAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEVIRTUAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEVIRTUAL(
+ long iid, long invokeId, String owner, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKEVIRTUAL(iid, invokeId, owner, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKESPECIAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKESPECIAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKESPECIAL(
+ long iid, long invokeId, String owner, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKESPECIAL(iid, invokeId, owner, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEDYNAMIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEDYNAMIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEDYNAMIC(
+ long iid, long invokeId, String owner, String name, String desc, String lambda) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKEDYNAMIC(iid, invokeId, owner, name, desc, lambda);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKESTATIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKESTATIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKESTATIC(
+ long iid, long invokeId, String owner, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKESTATIC(iid, invokeId, owner, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEINTERFACE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEINTERFACE}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ * @param owner the owner of the method
+ * @param name the name of the method
+ * @param desc the descriptor of the method
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEINTERFACE(
+ long iid, long invokeId, String owner, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKEINTERFACE(iid, invokeId, owner, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETSTATIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETSTATIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void GETSTATIC(long iid, int cIdx, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETSTATIC(iid, cIdx, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the PUTSTATIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.PUTSTATIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void PUTSTATIC(long iid, int cIdx, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.PUTSTATIC(iid, cIdx, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETFIELD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETFIELD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void GETFIELD(long iid, int cIdx, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETFIELD(iid, cIdx, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the PUTFIELD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.PUTFIELD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx class index.
+ * @param name field name.
+ * @param desc field descriptor.
+ */
+ @SuppressWarnings("unused")
+ public static void PUTFIELD(long iid, int cIdx, String name, String desc) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.PUTFIELD(iid, cIdx, name, desc);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NEW instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NEW}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type of the object to be created
+ * @param cIdx the class index
+ */
+ @SuppressWarnings("unused")
+ public static void NEW(long iid, String type, int cIdx) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.NEW(iid, type, cIdx);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CLINIT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CLINIT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param cIdx the class index
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void CLINIT(long iid, int cIdx, long invokeId) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.CLINIT(iid, cIdx, invokeId);
+ }
+
+ /**
+ * When a method is invoked with reflection, the jvm will compile code that adds all parameters
+ * to an array and adds this array to the frame, instead of adding all parameters to the frame.
+ *
+ * The called method however receives the unpackaged parameters. Since the unpacking code is
+ * not instrumented, we add a helper method to do the unpacking for us.
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void UNPACK_INVOKE_PARAMETER(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.UNPACK_INVOKE_PARAMETER(iid);
+ }
+
+ @SuppressWarnings("unused")
+ public static void SET_FIELD_REFLECTION(String owner, String name, String desc, String reflectFieldName, String reflectObjectOwner, boolean isWideOperand, int modifiers, long iid, long invokeId) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.SET_FIELD_REFLECTION(owner, name, desc, reflectFieldName, reflectObjectOwner, isWideOperand, modifiers, iid, invokeId);
+ }
+
+ @SuppressWarnings("unused")
+ public static void GET_FIELD_REFLECTION(String owner, String name, String desc, String reflectFieldName, String reflectObjectOwner, int modifiers, long iid, long invokeId) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GET_FIELD_REFLECTION(owner, name, desc, reflectFieldName, reflectObjectOwner, modifiers, iid, invokeId);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ANEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ANEWARRAY}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type type of the array to create.
+ */
+ @SuppressWarnings("unused")
+ public static void ANEWARRAY(long iid, String type) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ANEWARRAY(iid, type);
+ }
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CHECKCAST instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CHECKCAST}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type to check against
+ */
+ @SuppressWarnings("unused")
+ public static void CHECKCAST(long iid, String type) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.CHECKCAST(iid, type);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INSTANCEOF instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INSTANCEOF}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param type the type to check against
+ */
+ @SuppressWarnings("unused")
+ public static void INSTANCEOF(long iid, String type) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INSTANCEOF(iid, type);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BIPUSH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BIPUSH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param value the value to be pushed.
+ */
+ @SuppressWarnings("unused")
+ public static void BIPUSH(long iid, int value) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.BIPUSH(iid, value);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SIPUSH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SIPUSH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param value the value to be pushed.
+ */
+ @SuppressWarnings("unused")
+ public static void SIPUSH(long iid, int value) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.SIPUSH(iid, value);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NEWARRAY instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NEWARRAY}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param atype the type of the array to be created
+ */
+ @SuppressWarnings("unused")
+ public static void NEWARRAY(long iid, int atype) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.NEWARRAY(iid, atype);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ILOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ILOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ILOAD(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ILOAD(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void LLOAD(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LLOAD(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void FLOAD(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FLOAD(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DLOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DLOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void DLOAD(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DLOAD(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ALOAD(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ALOAD(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ISTORE(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ISTORE(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void LSTORE(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LSTORE(iid, var);
+ }
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void FSTORE(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FSTORE(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DSTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DSTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void DSTORE(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DSTORE(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index
+ */
+ @SuppressWarnings("unused")
+ public static void ASTORE(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ASTORE(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the RET instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.RET}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param var local variable index to the return address
+ */
+ @SuppressWarnings("unused")
+ public static void RET(long iid, int var) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.RET(iid, var);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the NOP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.NOP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void NOP(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.NOP(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ACONST_NULL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ACONST_NULL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ACONST_NULL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ACONST_NULL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_M1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_M1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_M1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_M1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_0(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_0(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_2(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_2(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_3 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_3}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_3(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_3(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_4 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_4}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_4(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_4(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ICONST_5 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ICONST_5}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ICONST_5(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ICONST_5(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCONST_0(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LCONST_0(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCONST_1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LCONST_1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_0(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FCONST_0(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FCONST_1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCONST_2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCONST_2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCONST_2(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FCONST_2(iid);
+ }
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCONST_0 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCONST_0}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCONST_0(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DCONST_0(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCONST_1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCONST_1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCONST_1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DCONST_1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the AALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.AALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void AALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.AALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void BALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.BALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void CALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.CALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SALOAD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SALOAD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SALOAD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.SALOAD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the AASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.AASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void AASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.AASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the BASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.BASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void BASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.BASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the CASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.CASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void CASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.CASTORE(iid);
+ }
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SASTORE instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SASTORE}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SASTORE(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.SASTORE(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the POP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.POP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void POP(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.POP(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the POP2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.POP2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void POP2(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.POP2(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DUP(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP_X1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP_X1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP_X1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DUP_X1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP_X2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP_X2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP_X2(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DUP_X2(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DUP2(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2_X1 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2_X1}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2_X1(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DUP2_X1(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DUP2_X2 instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DUP2_X2}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DUP2_X2(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DUP2_X2(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SWAP instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SWAP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void SWAP(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.SWAP(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IADD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IADD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LADD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LADD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FADD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FADD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DADD instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DADD}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DADD(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DADD(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISUB(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ISUB(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSUB(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LSUB(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FSUB(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FSUB(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DSUB instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DSUB}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DSUB(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DSUB(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IMUL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IMUL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LMUL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LMUL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FMUL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FMUL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DMUL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DMUL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DMUL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DMUL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IDIV(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IDIV(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LDIV(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LDIV(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FDIV(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FDIV(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DDIV instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DDIV}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DDIV(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DDIV(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IREM(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IREM(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LREM(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LREM(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FREM(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FREM(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DREM instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DREM}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DREM(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DREM(iid);
+ }
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void INEG(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INEG(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LNEG(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LNEG(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FNEG(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FNEG(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DNEG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DNEG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DNEG(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DNEG(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISHL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISHL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISHL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ISHL(iid);
+ }
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSHL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSHL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSHL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LSHL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ISHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ISHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ISHR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ISHR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LSHR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LSHR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IUSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IUSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IUSHR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IUSHR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LUSHR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LUSHR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LUSHR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LUSHR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IAND instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IAND}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IAND(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IAND(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LAND instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LAND}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LAND(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LAND(iid);
+ }
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IOR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IOR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IOR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOR instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LOR(iid);
+ }
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IXOR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IXOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IXOR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IXOR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LXOR instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LXOR}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LXOR(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LXOR(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2L(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.I2L(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2F(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.I2F(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2D(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.I2D(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2I(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.L2I(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2F(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.L2F(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the L2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.L2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void L2D(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.L2D(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2I(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.F2I(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2L(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.F2L(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the F2D instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.F2D}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void F2D(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.F2D(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2I instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2I}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2I(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.D2I(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2L instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2L}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2L(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.D2L(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the D2F instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.D2F}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void D2F(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.D2F(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2B instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2B}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2B(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.I2B(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2C instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2C}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2C(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.I2C(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the I2S instruction is executed in an instrumented
+ * region, this method is called. Parameters provide additional extracted information necessary
+ * for handling this instruction symbolically. For more information regarding the handling of
+ * this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.I2S}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void I2S(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.I2S(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LCMP instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LCMP}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LCMP(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LCMP(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCMPL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCMPL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCMPL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FCMPL(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FCMPG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FCMPG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FCMPG(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FCMPG(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCMPL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCMPL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCMPL(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DCMPL(iid);
+ }
+
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DCMPG instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DCMPG}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DCMPG(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DCMPG(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the IRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.IRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void IRETURN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.IRETURN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LRETURN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LRETURN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the FRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.FRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void FRETURN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.FRETURN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the DRETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.DRETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void DRETURN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.DRETURN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ARETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ARETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ARETURN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ARETURN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the RETURN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.RETURN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void RETURN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.RETURN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ARRAYLENGTH instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ARRAYLENGTH}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ARRAYLENGTH(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ARRAYLENGTH(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the ATHROW instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.ATHROW}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void ATHROW(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.ATHROW(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MONITORENTER instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MONITORENTER}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MONITORENTER(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.MONITORENTER(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MONITOREXIT instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MONITOREXIT}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MONITOREXIT(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.MONITOREXIT(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_double instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_double}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_double(double v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_double(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_long instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_long}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_long(long v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_long(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_Object instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_Object}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_Object(Object v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_Object(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_boolean instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_boolean}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_boolean(boolean v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_boolean(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_byte instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_byte}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_byte(byte v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_byte(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_char instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_char}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_char(char v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_char(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_float instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_float}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_float(float v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_float(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_int instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_int}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_int(int v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_int(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_short instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_short}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param v the concrete value
+ * @param i an identifier
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_short(short v, long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_short(iid, v, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the GETVALUE_void instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.GETVALUE_void}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void GETVALUE_void(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.GETVALUE_void(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEMETHOD_EXCEPTION instruction is executed
+ * in an instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEMETHOD_EXCEPTION}. The instruction is handled in
+ * the {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEMETHOD_EXCEPTION(long iid, long invokeId) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKEMETHOD_EXCEPTION(iid, invokeId);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKEMETHOD_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKEMETHOD_END}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKEMETHOD_END(long iid, long invokeId) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKEMETHOD_END(iid, invokeId);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the INVOKECLINIT_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.INVOKECLINIT_END}. The instruction is handled in the
+ * {@link de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor
+ * SymbolicInstructionProcessor} that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param invokeId ID that matches an invoke with it's end or exeception
+ */
+ @SuppressWarnings("unused")
+ public static void INVOKECLINIT_END(long iid, long invokeId) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.INVOKECLINIT_END(iid, invokeId);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the SPECIAL instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.SPECIAL}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ * @param i marker used in symbolic interpreter for example for branch detection.
+ */
+ @SuppressWarnings("unused")
+ public static void SPECIAL(long iid, int i) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.SPECIAL(iid, i);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the MAKE_SYMBOLIC instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.MAKE_SYMBOLIC}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitMAKE_SYMBOLIC(MAKE_SYMBOLIC)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void MAKE_SYMBOLIC(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.MAKE_SYMBOLIC(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOP_BEGIN instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOOP_BEGIN}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitLOOP_BEGIN(LOOP_BEGIN)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOP_BEGIN(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LOOP_BEGIN(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the LOOP_END instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the Instruction itself: {@link
+ * de.uzl.its.swat.symbolic.instruction.LOOP_END}. The instruction is handled in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor SymbolicInstructionProcessor}
+ * that invokes the corresponding visitor method: {@link
+ * SymbolicInstructionVisitor#visitLOOP_END(LOOP_END)}
+ *
+ * @param iid The unique instruction ID set during instrumentation.
+ */
+ @SuppressWarnings("unused")
+ public static void LOOP_END(long iid) {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.LOOP_END(iid);
+ }
+
+ /**
+ * Method used to interact between the concrete and symbolic execution. The call to this method
+ * is added during instrumentation. Each time the flush instruction is executed in an
+ * instrumented region, this method is called. Parameters provide additional extracted
+ * information necessary for handling this instruction symbolically. For more information
+ * regarding the handling of this instruction look at the visitor method in the {@link
+ * de.uzl.its.swat.symbolic.processor.SymbolicInstructionProcessor}.
+ */
+ @SuppressWarnings("unused")
+ public static void flush() {
+ InstructionProcessor instructionProcessor =
+ ThreadHandler.getProcessor(Thread.currentThread().getId());
+ instructionProcessor.flush();
+ }
+}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AALOAD.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AALOAD.java
index a29700c..f9220fc 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AALOAD.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AALOAD.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* AALOAD - Load reference from array. For more information see the Java VM
@@ -11,10 +13,9 @@ public class AALOAD extends Instruction {
* Creates a new AALOAD instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public AALOAD(int iid, int mid) {
- super(iid, mid);
+ public AALOAD(long iid) {
+ super(iid);
}
/**
@@ -22,7 +23,7 @@ public AALOAD(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitAALOAD(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AASTORE.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AASTORE.java
index 2d634cd..6ebc3de 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AASTORE.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/AASTORE.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* AASTORE - Store into reference array For more information see the Java VM
@@ -10,10 +12,9 @@ public class AASTORE extends Instruction {
* Creates a new AASTORE instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public AASTORE(int iid, int mid) {
- super(iid, mid);
+ public AASTORE(long iid) {
+ super(iid);
}
/**
@@ -21,7 +22,7 @@ public AASTORE(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitAASTORE(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ACONST_NULL.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ACONST_NULL.java
index 5795cfe..cef4b98 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ACONST_NULL.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ACONST_NULL.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* ACONST_NULL - Push null. For more information see the Java
@@ -11,10 +13,9 @@ public class ACONST_NULL extends Instruction {
* Creates a new ACONST_NULL instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public ACONST_NULL(int iid, int mid) {
- super(iid, mid);
+ public ACONST_NULL(long iid) {
+ super(iid);
}
/**
@@ -22,7 +23,7 @@ public ACONST_NULL(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitACONST_NULL(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ALOAD.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ALOAD.java
index 559e011..2397985 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ALOAD.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ALOAD.java
@@ -1,4 +1,6 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
/**
* ALOAD - Load reference from local variable. For more information see the Java VM
@@ -13,11 +15,10 @@ public class ALOAD extends Instruction {
* Creates a new ALOAD instruction.
*
* @param iid instruction id.
- * @param mid method id.
* @param var index of the local variable to load.
*/
- public ALOAD(int iid, int mid, int var) {
- super(iid, mid);
+ public ALOAD(long iid, int var) {
+ super(iid);
this.var = var;
}
@@ -26,7 +27,7 @@ public ALOAD(int iid, int mid, int var) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitALOAD(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ANEWARRAY.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ANEWARRAY.java
index 78fba74..8158eec 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ANEWARRAY.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ANEWARRAY.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* ANEWARRAY - Create new array of reference. For more information see the Java VM
@@ -13,11 +15,10 @@ public class ANEWARRAY extends Instruction {
* Creates a new ANEWARRAY instruction.
*
* @param iid instruction id.
- * @param mid method id.
* @param type type of the array to create.
*/
- public ANEWARRAY(int iid, int mid, String type) {
- super(iid, mid);
+ public ANEWARRAY(long iid, String type) {
+ super(iid);
this.type = type;
}
@@ -26,7 +27,7 @@ public ANEWARRAY(int iid, int mid, String type) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitANEWARRAY(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARETURN.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARETURN.java
index d4d5261..42af211 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARETURN.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARETURN.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* ARETURN - Return reference from method. For more information see the Java VM
@@ -10,10 +12,9 @@ public class ARETURN extends Instruction {
* Creates a new ARETURN instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public ARETURN(int iid, int mid) {
- super(iid, mid);
+ public ARETURN(long iid) {
+ super(iid);
}
/**
@@ -21,7 +22,7 @@ public ARETURN(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitARETURN(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARRAYLENGTH.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARRAYLENGTH.java
index 8ecff3c..4721d7b 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARRAYLENGTH.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ARRAYLENGTH.java
@@ -1,4 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* ARRAYLENGTH - Get length of array. For more information see the Java
@@ -10,10 +13,9 @@ public class ARRAYLENGTH extends Instruction {
* Creates a new ARRAYLENGTH instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public ARRAYLENGTH(int iid, int mid) {
- super(iid, mid);
+ public ARRAYLENGTH(long iid) {
+ super(iid);
}
/**
@@ -21,7 +23,7 @@ public ARRAYLENGTH(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitARRAYLENGTH(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ASTORE.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ASTORE.java
index 410929c..eabbd48 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ASTORE.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ASTORE.java
@@ -1,4 +1,6 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
/**
* ASTORE -Store reference into local variable. For more information see the Java VM
@@ -13,11 +15,10 @@ public class ASTORE extends Instruction {
* Creates a new ASTORE instruction.
*
* @param iid instruction id.
- * @param mid method id.
* @param var index of the local variable where the reference is stored.
*/
- public ASTORE(int iid, int mid, int var) {
- super(iid, mid);
+ public ASTORE(long iid, int var) {
+ super(iid);
this.var = var;
}
/**
@@ -25,7 +26,7 @@ public ASTORE(int iid, int mid, int var) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitASTORE(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ATHROW.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ATHROW.java
index 4fa9f98..e14ba8a 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ATHROW.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/ATHROW.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* ATHROW - Throw exception or error. For more information see the Java VM
@@ -11,10 +13,9 @@ public class ATHROW extends Instruction {
* Creates a new ALOAD instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public ATHROW(int iid, int mid) {
- super(iid, mid);
+ public ATHROW(long iid) {
+ super(iid);
}
/**
@@ -22,7 +23,7 @@ public ATHROW(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitATHROW(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BALOAD.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BALOAD.java
index 0577751..bb3bac2 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BALOAD.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BALOAD.java
@@ -1,4 +1,6 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
/**
* BALOAD - Load byte or boolean from array. For more information see the Java VM
@@ -9,10 +11,9 @@ public class BALOAD extends Instruction {
* Creates a new BALOAD instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public BALOAD(int iid, int mid) {
- super(iid, mid);
+ public BALOAD(long iid) {
+ super(iid);
}
/**
@@ -20,7 +21,7 @@ public BALOAD(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitBALOAD(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BASTORE.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BASTORE.java
index 46fc742..d47e5be 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BASTORE.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BASTORE.java
@@ -1,4 +1,6 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
/**
* BASTORE - Store into byte or boolean array. For more information see the Java VM
@@ -9,10 +11,9 @@ public class BASTORE extends Instruction {
* Creates a new BASTORE instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public BASTORE(int iid, int mid) {
- super(iid, mid);
+ public BASTORE(long iid) {
+ super(iid);
}
/**
@@ -20,7 +21,7 @@ public BASTORE(int iid, int mid) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitBASTORE(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BIPUSH.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BIPUSH.java
index 8a4fec6..348616d 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BIPUSH.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/BIPUSH.java
@@ -1,4 +1,6 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
/**
* BIPUSH - Push byte. For more information see the Java VM
@@ -12,11 +14,10 @@ public class BIPUSH extends Instruction {
* Creates a new BIPUSH instruction.
*
* @param iid instruction id.
- * @param mid method id.
* @param value the value to be pushed.
*/
- public BIPUSH(int iid, int mid, int value) {
- super(iid, mid);
+ public BIPUSH(long iid, int value) {
+ super(iid);
this.value = value;
}
@@ -25,7 +26,7 @@ public BIPUSH(int iid, int mid, int value) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitBIPUSH(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CALOAD.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CALOAD.java
index 9c1716b..7f08d76 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CALOAD.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CALOAD.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* CALOAD - Load char from array. For more information see the Java VM
@@ -10,17 +12,16 @@ public class CALOAD extends Instruction {
* Creates a new CALOAD instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public CALOAD(int iid, int mid) {
- super(iid, mid);
+ public CALOAD(long iid) {
+ super(iid);
}
/**
* Accept method for the visitor.
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitCALOAD(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CASTORE.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CASTORE.java
index 421a6d4..f179218 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CASTORE.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CASTORE.java
@@ -1,4 +1,6 @@
package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
/**
* CASTORE - Store into char array. For more information see the Java VM
@@ -9,17 +11,16 @@ public class CASTORE extends Instruction {
* Creates a new CASTORE instruction.
*
* @param iid instruction id.
- * @param mid method id.
*/
- public CASTORE(int iid, int mid) {
- super(iid, mid);
+ public CASTORE(long iid) {
+ super(iid);
}
/**
* Accept method for the visitor.
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitCASTORE(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CHECKCAST.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CHECKCAST.java
index c24363d..0a889eb 100644
--- a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CHECKCAST.java
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CHECKCAST.java
@@ -1,5 +1,7 @@
package de.uzl.its.swat.symbolic.instruction;
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
/**
* CHECKCAST - Check whether object is of given type. For more information see the Java VM
@@ -13,11 +15,10 @@ public class CHECKCAST extends Instruction {
* Creates a new CHECKCAST instruction.
*
* @param iid instruction id.
- * @param mid method id.
* @param type the type to check against
*/
- public CHECKCAST(int iid, int mid, String type) {
- super(iid, mid);
+ public CHECKCAST(long iid, String type) {
+ super(iid);
this.type = type;
}
@@ -26,7 +27,7 @@ public CHECKCAST(int iid, int mid, String type) {
*
* @param visitor the visitor
*/
- public void accept(IVisitor visitor) {
+ public void accept(IVisitor visitor) throws SymbolicInstructionException {
visitor.visitCHECKCAST(this);
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CLINIT.java b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CLINIT.java
new file mode 100644
index 0000000..98dbd6f
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/symbolic/instruction/CLINIT.java
@@ -0,0 +1,54 @@
+package de.uzl.its.swat.symbolic.instruction;
+
+import de.uzl.its.swat.common.exceptions.SymbolicInstructionException;
+
+/**
+ * NEW - Create new object. For more information see the Java VM
+ * specification.
+ */
+public class CLINIT extends InvokeIdInstruction {
+
+ // The type of the object to be created
+ // String type;
+
+ // The class index
+ public int cIdx;
+ public final String desc = "()V";
+ public final String name = "
+ * LDC uid
+ * INVOKESTATIC Intrinsics.injectAssignment(uid, value)
+ * LDC uid
+ * INVOKESTATIC Intrinsics.liftValue(uid, value)
+ *
+ * @param type The type of the value to be lifted.
+ * @return The sequence of instructions.
+ */
+ public static InsnList createLiftInstrumentation(Type type, boolean addAssignment, boolean prefixOnStack, String prefix) {
+ // Note: The value to be lifted (and the prefix) is assumed to be on the top of the stack!
+ // [val, (prefix)]
+ InsnList list = new InsnList();
+ long uid = Intrinsics.getNextUid();
+ String desc = String.format("(%sJ)%s", type.getDescriptor(), type.getDescriptor());
+
+ if(prefixOnStack) {
+ SWATAssert.check(prefix == null, "Prefix must be null if prefixOnStack is true");
+ SWATAssert.check(!addAssignment, "Cannot add assignment if prefix is on stack (not implemented)");
+ desc = String.format("(%sLjava/lang/String;J)%s", type.getDescriptor(), type.getDescriptor());
+ // [val, prefix]
+ } else{
+ if(addAssignment) {
+ SWATAssert.check(prefix == null, "Prefix must be null if addAssignment is true (not implemented)");
+ // [val]
+ // Add the unique identifier for the value to be lifted.
+ list.add(new LdcInsnNode(uid));
+ list.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
+ Type.getInternalName(Intrinsics.class),
+ "injectAssignment",
+ desc,
+ false));
+ // [val]
+ }
+ if(prefix != null) {
+ // Add the prefix for the value to be lifted.
+ list.add(new LdcInsnNode(prefix));
+ desc = String.format("(%sLjava/lang/String;J)%s", type.getDescriptor(), type.getDescriptor());
+ // [val, prefix]
+ }
+ }
+ // Add the unique identifier for the value to be lifted.
+ list.add(new LdcInsnNode(uid));
+ // [val, (prefix), uid]
+
+ list.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
+ Type.getInternalName(Intrinsics.class),
+ "liftValue",
+ desc,
+ false));
+ // [val]
+ return list;
+ }
+
+
+ /**
+ * Creates an instruction list that loads a local variable, and lifts it to the symbolic domain,
+ * while also checking if an assignment is available for the variable.
+ *
+ * @param localIndex the index of the local variable to instrument
+ * @param loadOpcode the opcode used to load the variable
+ * @param storeOpcode the opcode used to store the result
+ * @param type the type descriptor of the variable
+ * @return an {@code InsnList} containing the instrumentation instructions
+ */
+ public static InsnList liftLocalVariable(int localIndex, int loadOpcode, int storeOpcode, Type type, boolean addAssignment) {
+ InsnList list = new InsnList();
+ list.add(new VarInsnNode(loadOpcode, localIndex));
+ list.add(Utils.createLiftInstrumentation(type, addAssignment, false, null));
+ list.add(new VarInsnNode(storeOpcode, localIndex));
+ return list;
+ }
+
+ /**
+ * Creates an instruction list that iterates through a list
+ * and lifts each element individually to the symbolic domain.
+ * If localIndex is -1 the list is assumed to be on the stack.
+ *
+ * @param localIndex the index of the local variable to instrument
+ * @param addAssignment whether to add assignment tracking
+ * @param leaveOnStack whether to leave the list reference on the stack after instrumentation (true for field lifting, false for parameter initialization)
+ * @return an {@code InsnList} containing the instrumentation instructions
+ */
+ public static InsnList liftListVariable(int localIndex, boolean addAssignment, boolean leaveOnStack) {
+ // If the list is on top of the stack, set localIndex to -1
+ InsnList list = new InsnList();
+ String symPrefix = "List";
+
+ if(localIndex != -1) { // Load the list from local variable
+ list.add(new VarInsnNode(Opcodes.ALOAD, localIndex));
+ }
+ // Stack: [list]
+
+ // Check if list is null
+ LabelNode nullLabel = new LabelNode();
+ LabelNode endLabel = new LabelNode();
+ list.add(new InsnNode(Opcodes.DUP));
+ list.add(new JumpInsnNode(Opcodes.IFNULL, nullLabel));
+ // Stack: [list]
+
+ list.add(new InsnNode(Opcodes.DUP));
+ // Stack: [list, list]
+
+ // Get ListIterator: list.listIterator()
+ list.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/List", "listIterator", "()Ljava/util/ListIterator;", true));
+ // Stack: [list, listIterator]
+
+ // Loop through ListIterator
+ LabelNode loopStart = new LabelNode();
+ LabelNode loopEnd = new LabelNode();
+
+ list.add(loopStart);
+
+ // Check if iterator has next: listIterator.hasNext()
+ list.add(new InsnNode(Opcodes.DUP));
+ list.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/ListIterator", "hasNext", "()Z", true));
+ list.add(new JumpInsnNode(Opcodes.IFEQ, loopEnd));
+ // Stack: [list, listIterator]
+
+ // Get next element: listIterator.next()
+ list.add(new InsnNode(Opcodes.DUP));
+ list.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/ListIterator", "next", "()Ljava/lang/Object;", true));
+ // Stack: [list, listIterator, element]
+
+ // Apply lift instrumentation to the element
+ Type elementType = Type.getType(Object.class);
+ list.add(Utils.createLiftInstrumentation(elementType, addAssignment, false, symPrefix));
+ // Stack: [list, listIterator, liftedElement]
+
+ // Since we track by address, no need to put the element back - just pop the lifted element
+ list.add(new InsnNode(Opcodes.POP));
+ // Stack: [list, listIterator]
+
+ // Jump back to loop start
+ list.add(new JumpInsnNode(Opcodes.GOTO, loopStart));
+
+ // Loop end - pop the listIterator and jump to end
+ list.add(loopEnd);
+ // Stack: [list, listIterator]
+ list.add(new InsnNode(Opcodes.POP));
+ // Stack: [list]
+ list.add(new JumpInsnNode(Opcodes.GOTO, endLabel));
+
+ list.add(nullLabel);
+ // Stack: [list]
+
+ // End label
+ list.add(endLabel);
+ // Stack: [list]
+
+ if (!leaveOnStack) {
+ // For parameter initialization: pop the list to leave empty stack
+ list.add(new InsnNode(Opcodes.POP));
+ // Stack: []
+ }
+ // Stack: [list] if leaveOnStack, [] otherwise
+
+ return list;
+ }
+
+ public static boolean isStatic(int access) {
+ return (access & Opcodes.ACC_STATIC) != 0;
+ }
public static void addBipushInsn(MethodVisitor mv, int val) {
switch (val) {
@@ -20,10 +266,16 @@ public static void addBipushInsn(MethodVisitor mv, int val) {
}
}
+ public static void addJpushInsn(MethodVisitor mv, long val) {
+ mv.visitLdcInsn(val);
+ }
+
public static void addSpecialInsn(MethodVisitor mv, int val) {
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, val);
+
mv.visitMethodInsn(
- INVOKESTATIC, config.getInstrumentationDispatcher(), "SPECIAL", "(I)V", false);
+ INVOKESTATIC, config.getInstrumentationDispatcher(), "SPECIAL", "(JI)V", false);
}
/**
@@ -36,9 +288,7 @@ public static void addValueReadInsn(MethodVisitor mv, String desc, String method
if (desc.contains(":")) {
String[] s = desc.split(":");
- if (s.length != 3)
- throw new RuntimeException(
- "Unexpected description (Expected \"owner:name:desc\"): " + desc);
+ SWATAssert.check(s.length == 3, "Unexpected description (Expected \"owner:name:desc\"): {}", desc);
desc = s[2];
}
@@ -50,104 +300,160 @@ public static void addValueReadInsn(MethodVisitor mv, String desc, String method
switch (t.getSort()) {
case Type.DOUBLE -> {
mv.visitInsn(DUP2);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "double",
- "(DI)V",
+ "(DJI)V",
false);
}
case Type.LONG -> {
mv.visitInsn(DUP2);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "long",
- "(JI)V",
+ "(JJI)V",
false);
}
case Type.ARRAY, Type.OBJECT -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "Object",
- "(Ljava/lang/Object;I)V",
+ "(Ljava/lang/Object;JI)V",
false);
}
case Type.BOOLEAN -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "boolean",
- "(ZI)V",
+ "(ZJI)V",
false);
}
case Type.BYTE -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "byte",
- "(BI)V",
+ "(BJI)V",
false);
}
case Type.CHAR -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "char",
- "(CI)V",
+ "(CJI)V",
false);
}
case Type.FLOAT -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "float",
- "(FI)V",
+ "(FJI)V",
false);
}
case Type.INT -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "int",
- "(II)V",
+ "(IJI)V",
false);
}
case Type.SHORT -> {
mv.visitInsn(DUP);
+ addJpushInsn(mv, instrumentationState.incAndGetId());
addBipushInsn(mv, identifier);
mv.visitMethodInsn(
INVOKESTATIC,
config.getInstrumentationDispatcher(),
methodNamePrefix + "short",
- "(SI)V",
+ "(SJI)V",
+ false);
+ }
+ case Type.VOID -> {
+ addJpushInsn(mv, instrumentationState.incAndGetId());
+ mv.visitMethodInsn(
+ INVOKESTATIC,
+ config.getInstrumentationDispatcher(),
+ methodNamePrefix + "void",
+ "(J)V",
false);
}
- case Type.VOID -> mv.visitMethodInsn(
- INVOKESTATIC,
- config.getInstrumentationDispatcher(),
- methodNamePrefix + "void",
- "()V",
- false);
default -> {
System.err.println("Unknown field or method descriptor " + desc);
System.exit(1);
}
}
}
+
+ /**
+ * Adds either the beginning of the try block or the end of the try block including the catch block.
+ * @param mv The method visitor
+ * @param begin True if the beginning of the try block should be added, false if the end of the try block should be added
+ */
+ public static void addTryCatchBlock(MethodVisitor mv, boolean begin, TryCatchBlock tryCatchBlock){
+ if (begin) {
+ // Add the beginning of the try block
+ tryCatchBlock.visit(mv);
+ mv.visitLabel(tryCatchBlock.start());
+ } else {
+ // Add the end of the try block and the catch block
+ mv.visitLabel(tryCatchBlock.end());
+ mv.visitJumpInsn(Opcodes.GOTO, tryCatchBlock.jumpTarget());
+ mv.visitLabel(tryCatchBlock.handler());
+
+ mv.visitInsn(Opcodes.DUP); // The exception object is on the stack
+
+ mv.visitMethodInsn(
+ Opcodes.INVOKEVIRTUAL, "java/lang/Throwable", "printStackTrace", "()V", false);
+ // Print string unsing system.out
+ mv.visitFieldInsn(
+ Opcodes.GETSTATIC,
+ "java/lang/System",
+ "out",
+ "Ljava/io/PrintStream;");
+ mv.visitLdcInsn("[SWAT] Unrecoverable exception in symbolic execution");
+ mv.visitMethodInsn(
+ Opcodes.INVOKEVIRTUAL,
+ "java/io/PrintStream",
+ "println",
+ "(Ljava/lang/String;)V",
+ false);
+
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Runtime", "getRuntime", "()Ljava/lang/Runtime;", false);
+ mv.visitLdcInsn(1);
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Runtime", "exit", "(I)V", false);
+ mv.visitInsn(Opcodes.ATHROW); // Rethrow the exception. This will never happen due to the exit call above but the verifier does not know that.
+ mv.visitLabel(tryCatchBlock.jumpTarget());
+
+
+ }
+ }
}
diff --git a/symbolic-executor/src/main/java/de/uzl/its/swat/instrument/annotation/AnnotationClassAdapter.java b/symbolic-executor/src/main/java/de/uzl/its/swat/instrument/annotation/AnnotationClassAdapter.java
new file mode 100644
index 0000000..e64789c
--- /dev/null
+++ b/symbolic-executor/src/main/java/de/uzl/its/swat/instrument/annotation/AnnotationClassAdapter.java
@@ -0,0 +1,97 @@
+package de.uzl.its.swat.instrument.annotation;
+
+import de.uzl.its.swat.common.Util;
+import de.uzl.its.swat.instrument.common.FieldInfo;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A {@code ClassVisitor} that instruments classes to support symbolic execution by handling
+ * the {@code @Symbolic} annotation. This adapter instruments:
+ *
+ *
+ */
+public class AnnotationClassAdapter extends ClassVisitor {
+ private String className;
+ private final List
+ *
+ * {@link de.uzl.its.swat.metadata.ClassTemplate} is an abstract base for these template
+ * implementations.
+ *