/**
* Returns true if the two original variables are related in a way that makes subsequence or
* subset detection not informative.
*/
public static boolean isObviousSubSequenceDynamically(
Invariant inv, VarInfo subvar, VarInfo supervar) {
VarInfo[] vis = {subvar, supervar};
ProglangType rep1 = subvar.rep_type;
ProglangType rep2 = supervar.rep_type;
if (!(((rep1 == ProglangType.INT_ARRAY) && (rep2 == ProglangType.INT_ARRAY))
|| ((rep1 == ProglangType.DOUBLE_ARRAY) && (rep2 == ProglangType.DOUBLE_ARRAY))
|| ((rep1 == ProglangType.STRING_ARRAY) && (rep2 == ProglangType.STRING_ARRAY))))
return false;
if (debug.isLoggable(Level.FINE)) {
debug.fine(
"Checking isObviousSubSequenceDynamically " + subvar.name() + " in " + supervar.name());
}
Object[] di = isObviousSubSequence(subvar, supervar);
if (di[1] != null) {
inv.log("ObvSubSeq- true from isObviousSubSequence: " + di[1]);
return true;
}
debug.fine(" not isObviousSubSequence(statically)");
PptTopLevel ppt_parent = subvar.ppt;
// If the elements of supervar are always the same (EltOneOf),
// we aren't going to learn anything new from this invariant,
// since each sequence should have an EltOneOf over it.
if (false) {
PptSlice1 slice = ppt_parent.findSlice(supervar);
if (slice == null) {
System.out.println("No slice: parent =" + ppt_parent);
} else {
System.out.println("Slice var =" + slice.var_infos[0]);
for (Invariant superinv : slice.invs) {
System.out.println("Inv = " + superinv);
if (superinv instanceof EltOneOf) {
EltOneOf eltinv = (EltOneOf) superinv;
if (eltinv.num_elts() > 0) {
inv.log(" obvious because of " + eltinv.format());
return true;
}
}
}
}
}
// Obvious if subvar is always just []
if (true) {
PptSlice1 slice = ppt_parent.findSlice(subvar);
if (slice != null) {
for (Invariant subinv : slice.invs) {
if (subinv instanceof OneOfSequence) {
OneOfSequence seqinv = (OneOfSequence) subinv;
if (seqinv.num_elts() == 1) {
Object elt = seqinv.elt();
if (elt instanceof long[] && ((long[]) elt).length == 0) {
Debug.log(
debug, inv.getClass(), inv.ppt, vis, "ObvSubSeq- True from subvar being []");
return true;
}
if (elt instanceof double[] && ((double[]) elt).length == 0) {
inv.log("ObvSubSeq- True from subvar being []");
return true;
}
}
}
}
}
}
// Check for a[0..i] subseq a[0..j] but i < j.
VarInfo subvar_super = subvar.isDerivedSubSequenceOf();
VarInfo supervar_super = supervar.isDerivedSubSequenceOf();
if (subvar_super != null && subvar_super == supervar_super) {
// both sequences are derived from the same supersequence
if ((subvar.derived instanceof SequenceScalarSubsequence
|| subvar.derived instanceof SequenceScalarArbitrarySubsequence)
&& (supervar.derived instanceof SequenceScalarSubsequence
|| supervar.derived instanceof SequenceScalarArbitrarySubsequence)) {
VarInfo sub_left_var = null,
sub_right_var = null,
super_left_var = null,
super_right_var = null;
// I'm careful not to access foo_shift unless foo_var has been set
// to a non-null value, but Java is too stupid to recognize that.
int sub_left_shift = 42,
sub_right_shift = 69,
super_left_shift = 1492,
super_right_shift = 1776;
if (subvar.derived instanceof SequenceScalarSubsequence) {
SequenceScalarSubsequence sub = (SequenceScalarSubsequence) subvar.derived;
if (sub.from_start) {
sub_right_var = sub.sclvar();
sub_right_shift = sub.index_shift;
} else {
sub_left_var = sub.sclvar();
sub_left_shift = sub.index_shift;
}
} else if (subvar.derived instanceof SequenceScalarArbitrarySubsequence) {
SequenceScalarArbitrarySubsequence sub =
(SequenceScalarArbitrarySubsequence) subvar.derived;
sub_left_var = sub.startvar();
sub_left_shift = (sub.left_closed ? 0 : 1);
sub_right_var = sub.endvar();
sub_right_shift = (sub.right_closed ? 0 : -1);
} else {
Assert.assertTrue(false);
}
if (supervar.derived instanceof SequenceScalarSubsequence) {
SequenceScalarSubsequence super_ = (SequenceScalarSubsequence) supervar.derived;
if (super_.from_start) {
super_right_var = super_.sclvar();
super_right_shift = super_.index_shift;
} else {
super_left_var = super_.sclvar();
super_left_shift = super_.index_shift;
}
} else if (supervar.derived instanceof SequenceScalarArbitrarySubsequence) {
SequenceScalarArbitrarySubsequence super_ =
(SequenceScalarArbitrarySubsequence) supervar.derived;
super_left_var = super_.startvar();
super_left_shift = (super_.left_closed ? 0 : 1);
super_right_var = super_.endvar();
super_right_shift = (super_.right_closed ? 0 : -1);
} else {
Assert.assertTrue(false);
}
boolean left_included, right_included;
if (super_left_var == null) left_included = true;
else if (sub_left_var == null) // we know super_left_var != null here
left_included = false;
else
left_included =
VarInfo.compare_vars(
super_left_var, super_left_shift, sub_left_var, sub_left_shift, true /* <= */);
if (super_right_var == null) right_included = true;
else if (sub_right_var == null) // we know super_right_var != null here
right_included = false;
else
right_included =
VarInfo.compare_vars(
super_right_var,
super_right_shift,
sub_right_var,
sub_right_shift,
false /* >= */);
// System.out.println("Is " + subvar.name() + " contained in "
// + supervar.name()
// + "? left: " + left_included + ", right: "
// + right_included);
if (left_included && right_included) {
inv.log("ObvSubSeq- True a[0..i] subseq a[0..j] and i < j");
return true;
}
} else if ((subvar.derived instanceof SequenceStringSubsequence)
&& (supervar.derived instanceof SequenceStringSubsequence)) {
// Copied from just above
SequenceStringSubsequence sss1 = (SequenceStringSubsequence) subvar.derived;
SequenceStringSubsequence sss2 = (SequenceStringSubsequence) supervar.derived;
VarInfo index1 = sss1.sclvar();
int shift1 = sss1.index_shift;
boolean start1 = sss1.from_start;
VarInfo index2 = sss2.sclvar();
int shift2 = sss2.index_shift;
boolean start2 = sss2.from_start;
if (start1 == start2)
if (VarInfo.compare_vars(index1, shift1, index2, shift2, start1)) {
inv.log("True from comparing indices");
return true;
}
} else {
Assert.assertTrue(
false,
"how can this happen? "
+ subvar.name()
+ " "
+ subvar.derived.getClass()
+ " "
+ supervar.name()
+ " "
+ supervar.derived.getClass());
}
}
// Also need to check A[0..i] subseq A[0..j] via compare_vars.
// A subseq B[0..n] => A subseq B
List<Derivation> derivees = supervar.derivees();
// For each variable derived from supervar ("B")
for (Derivation der : derivees) {
// System.out.println(" ... der = " + der.getVarInfo().name() + " " + der);
if (der instanceof SequenceScalarSubsequence) {
// If that variable is "B[0..n]"
VarInfo supervar_part = der.getVarInfo();
// Get the canonical version; being equal to it is good enough.
if (supervar_part.get_equalitySet_leader() == subvar) {
Debug.log(debug, inv.getClass(), inv.ppt, vis, "ObvSubSeq- True from canonical leader");
return true;
}
if (supervar_part.isCanonical()) {
if (subvar == supervar_part) {
System.err.println(
"Error: variables "
+ subvar.name()
+ " and "
+ supervar_part.name()
+ " are identical. Canonical");
System.err.println(subvar.isCanonical());
System.err.println(supervar_part.isCanonical());
throw new Error();
}
// Check to see if there is a subsequence over the supervar
if (ppt_parent.is_subsequence(subvar, supervar_part)) {
if (Debug.logOn())
inv.log(
"ObvSubSeq- true from A subseq B[0..n] "
+ subvar.name()
+ "/"
+ supervar_part.name());
return (true);
}
}
}
}
return false;
}
/**
* This does the work of main, but it never calls System.exit, so it is appropriate to be called
* progrmmatically. Termination of the program with a message to the user is indicated by throwing
* Daikon.TerminationMessage.
*
* @see #main(String[])
* @see daikon.Daikon.TerminationMessage
*/
public static void mainHelper(final String[] args)
throws FileNotFoundException, StreamCorruptedException, OptionalDataException, IOException,
ClassNotFoundException {
daikon.LogHelper.setupLogs(daikon.LogHelper.INFO);
LongOpt[] longopts =
new LongOpt[] {
new LongOpt(Daikon.config_option_SWITCH, LongOpt.REQUIRED_ARGUMENT, null, 0),
new LongOpt(output_SWITCH, LongOpt.REQUIRED_ARGUMENT, null, 0),
new LongOpt(dir_SWITCH, LongOpt.REQUIRED_ARGUMENT, null, 0),
new LongOpt(conf_SWITCH, LongOpt.NO_ARGUMENT, null, 0),
new LongOpt(filter_SWITCH, LongOpt.NO_ARGUMENT, null, 0),
new LongOpt(Daikon.debugAll_SWITCH, LongOpt.NO_ARGUMENT, null, 0),
new LongOpt(Daikon.debug_SWITCH, LongOpt.REQUIRED_ARGUMENT, null, 0),
new LongOpt(Daikon.ppt_regexp_SWITCH, LongOpt.REQUIRED_ARGUMENT, null, 0),
new LongOpt(Daikon.track_SWITCH, LongOpt.REQUIRED_ARGUMENT, null, 0),
};
Getopt g = new Getopt("daikon.tools.InvariantChecker", args, "h", longopts);
int c;
while ((c = g.getopt()) != -1) {
switch (c) {
case 0:
// got a long option
String option_name = longopts[g.getLongind()].getName();
if (Daikon.help_SWITCH.equals(option_name)) {
System.out.println(usage);
throw new Daikon.TerminationMessage();
} else if (conf_SWITCH.equals(option_name)) {
doConf = true;
} else if (filter_SWITCH.equals(option_name)) {
doFilter = true;
} else if (dir_SWITCH.equals(option_name)) {
dir_file = new File(g.getOptarg());
if (!dir_file.exists() || !dir_file.isDirectory())
throw new Daikon.TerminationMessage("Error reading the directory " + dir_file);
} else if (output_SWITCH.equals(option_name)) {
output_file = new File(g.getOptarg());
output_stream = new PrintStream(new FileOutputStream(output_file));
} else if (Daikon.config_option_SWITCH.equals(option_name)) {
String item = g.getOptarg();
daikon.config.Configuration.getInstance().apply(item);
break;
} else if (Daikon.debugAll_SWITCH.equals(option_name)) {
Global.debugAll = true;
} else if (Daikon.debug_SWITCH.equals(option_name)) {
LogHelper.setLevel(g.getOptarg(), LogHelper.FINE);
} else if (Daikon.track_SWITCH.equals(option_name)) {
LogHelper.setLevel("daikon.Debug", LogHelper.FINE);
String error = Debug.add_track(g.getOptarg());
if (error != null) {
throw new Daikon.TerminationMessage(
"Error parsing track argument '" + g.getOptarg() + "' - " + error);
}
} else {
throw new RuntimeException("Unknown long option received: " + option_name);
}
break;
case 'h':
System.out.println(usage);
throw new Daikon.TerminationMessage();
case '?':
break; // getopt() already printed an error
default:
System.out.println("getopt() returned " + c);
break;
}
}
// Loop through each filename specified
for (int i = g.getOptind(); i < args.length; i++) {
// Get the file and make sure it exists
File file = new File(args[i]);
if (!file.exists()) {
throw new Error("File " + file + " not found.");
}
// These aren't "endsWith()" because there might be a suffix on the end
// (eg, a date).
String filename = file.toString();
if (filename.indexOf(".inv") != -1) {
if (inv_file != null) {
throw new Daikon.TerminationMessage("multiple inv files specified", usage);
}
inv_file = file;
} else if (filename.indexOf(".dtrace") != -1) {
dtrace_files.add(filename);
} else {
throw new Error("Unrecognized argument: " + file);
}
}
if (dir_file == null) {
checkInvariants();
return;
}
// Yoav additions:
File[] filesInDir = dir_file.listFiles();
if (filesInDir == null || filesInDir.length == 0)
throw new Daikon.TerminationMessage("The directory " + dir_file + " is empty", usage);
ArrayList<File> invariants = new ArrayList<File>();
for (File f : filesInDir) if (f.toString().indexOf(".inv") != -1) invariants.add(f);
if (invariants.size() == 0)
throw new Daikon.TerminationMessage(
"Did not find any invariant files in the directory " + dir_file, usage);
ArrayList<File> dtraces = new ArrayList<File>();
for (File f : filesInDir) if (f.toString().indexOf(".dtrace") != -1) dtraces.add(f);
if (dtraces.size() == 0)
throw new Daikon.TerminationMessage(
"Did not find any dtrace files in the directory " + dir_file, usage);
System.out.println(
"Collecting data for invariants files " + invariants + " and dtrace files " + dtraces);
dtrace_files.clear();
for (File dtrace : dtraces) {
dtrace_files.add(dtrace.toString());
}
String commaLine = "";
for (File inFile : invariants) {
String name = inFile.getName().replace(".inv", "").replace(".gz", "");
commaLine += "," + name;
}
outputComma.add(commaLine);
commaLine = "";
for (File inFile : invariants) {
inv_file = inFile;
failedInvariants.clear();
testedInvariants.clear();
error_cnt = 0;
output_stream =
new PrintStream(
new FileOutputStream(
inFile.toString().replace(".inv", "").replace(".gz", "")
+ ".false-positives.txt"));
checkInvariants();
output_stream.close();
int failedCount = failedInvariants.size();
int testedCount = testedInvariants.size();
String percent = toPercentage(failedCount, testedCount);
commaLine += "," + percent;
}
outputComma.add(commaLine);
System.out.println();
for (String output : outputComma) System.out.println(output);
}
public InvariantStatus add_modified(long[] a1, long[] a2, int count) {
InvariantStatus is = check_modified(a1, a2, count);
if ((is == InvariantStatus.FALSIFIED) && Debug.logOn())
log(format() + " destroyed by " + Debug.toString(a1) + " " + Debug.toString(a2));
return (is);
}
private void add(PptTopLevel ppt, ValueTuple vt) {
// Add the sample to any splitters
if (ppt.has_splitters()) {
for (PptSplitter ppt_split : ppt.splitters) {
PptConditional ppt_cond = ppt_split.choose_conditional(vt);
if (ppt_cond != null) add(ppt_cond, vt);
else debug.fine(": sample doesn't pick conditional");
}
}
// if this is a numbered exit, apply to the combined exit as well
if (!(ppt instanceof PptConditional) && ppt.ppt_name.isNumberedExitPoint()) {
PptTopLevel parent = all_ppts.get(ppt.ppt_name.makeExit());
if (parent != null) {
parent.get_missingOutOfBounds(ppt, vt);
add(parent, vt);
}
}
// If the point has no variables, skip it
if (ppt.var_infos.length == 0) return;
// We should have received sample here before, or there is nothing
// to check.
// Yoav added: It can be that the different dtrace and inv files have different program points
if (false && ppt.num_samples() <= 0)
Assert.assertTrue(
ppt.num_samples() > 0,
"ppt " + ppt.name + " has 0 samples and " + ppt.var_infos.length + " variables");
// Loop through each slice
slice_loop:
for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) {
PptSlice slice = i.next();
if (debug_detail.isLoggable(Level.FINE))
debug_detail.fine(
": processing slice " + slice + "vars: " + Debug.toString(slice.var_infos, vt));
// If any variables are missing, skip this slice
for (int j = 0; j < slice.var_infos.length; j++) {
VarInfo v = slice.var_infos[j];
int mod = vt.getModified(v);
if (v.isMissing(vt)) {
if (debug_detail.isLoggable(Level.FINE))
debug_detail.fine(": : Skipping slice, " + v.name() + " missing");
continue slice_loop;
}
if (v.missingOutOfBounds()) {
if (debug_detail.isLoggable(Level.FINE))
debug.fine(": : Skipping slice, " + v.name() + " out of bounds");
continue slice_loop;
}
}
// Loop through each invariant
for (Invariant inv : slice.invs) {
if (debug_detail.isLoggable(Level.FINE))
debug_detail.fine(": : Processing invariant: " + inv);
if (!inv.isActive()) {
if (debug_detail.isLoggable(Level.FINE))
debug_detail.fine(": : skipped non-active " + inv);
continue;
}
// Yoav added
if (!activeInvariants.contains(inv)) {
// System.out.printf ("skipping invariant %s:%s\n", inv.ppt.name(),
// inv.format());
continue;
}
// String invRep = invariant2str(ppt, inv);
testedInvariants.add(inv);
InvariantStatus status = inv.add_sample(vt, 1);
sample_cnt++;
if (status != InvariantStatus.NO_CHANGE) {
LineNumberReader lnr = FileIO.data_trace_state.reader;
String line = (lnr == null) ? "?" : String.valueOf(lnr.getLineNumber());
if (!quiet) {
output_stream.println(
"At ppt "
+ ppt.name
+ ", Invariant '"
+ inv.format()
+ "' invalidated by sample "
+ Debug.toString(slice.var_infos, vt)
+ "at line "
+ line
+ " in file "
+ FileIO.data_trace_state.filename);
}
failedInvariants.add(inv);
activeInvariants.remove(inv);
error_cnt++;
}
}
}
}