private void add(PptTopLevel ppt, ValueTuple vt, int nonce) {
// if this is a numbered exit, apply to the combined exit as well
if (ppt.ppt_name.isNumberedExitPoint()) {
// Daikon.create_combined_exits(all_ppts);
PptTopLevel parent = all_ppts.get(ppt.ppt_name.makeExit());
if (parent != null) {
parent.get_missingOutOfBounds(ppt, vt);
add(parent, vt, nonce);
} else {
// make parent and apply
// this is a hack. it should probably filter out orig and derived
// vars instead of taking the first n.
int len = ppt.num_tracevars + ppt.num_static_constant_vars;
VarInfo[] exit_vars = new VarInfo[len];
for (int j = 0; j < len; j++) {
exit_vars[j] = new VarInfo(ppt.var_infos[j]);
exit_vars[j].varinfo_index = ppt.var_infos[j].varinfo_index;
exit_vars[j].value_index = ppt.var_infos[j].value_index;
exit_vars[j].equalitySet = null;
}
parent = new PptTopLevel(ppt.ppt_name.makeExit().getName(), exit_vars);
Daikon.init_ppt(parent, all_ppts);
all_ppts.add(parent);
parent.get_missingOutOfBounds(ppt, vt);
add(parent, vt, nonce);
}
}
// If the point has no variables, skip it
if (ppt.var_infos.length == 0) {
// The sample should be skipped but Daikon does not do this so
// DaikonSimple will not do this to be consistent.
// The better idea is for Daikon to assert that these valuetuples are
// empty and then skip the sample.
assert vt.size() == 0;
return;
}
// Instantiate slices and invariants if this is the first sample
if (ppt.num_samples() == 0) {
instantiate_views_and_invariants(ppt);
}
// manually inc the sample number because DaikonSimple does not
// use any of PptTopLevel's add methods which increase the sample
// number
ppt.incSampleNumber();
// Loop through each slice
for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) {
PptSlice slice = i.next();
Iterator<Invariant> k = slice.invs.iterator();
boolean missing = false;
for (VarInfo v : slice.var_infos) {
// If any var has encountered out of array bounds values,
// stop all invariants in this slice. The presumption here is that
// an index out of bounds implies that the derived variable (eg a[i])
// doesn't really make any sense (essentially that i is not a valid
// index for a). Invariants on the derived variable are thus not
// relevant.
// If any variables are out of bounds, remove the invariants
if (v.missingOutOfBounds()) {
while (k.hasNext()) {
Invariant inv = k.next();
k.remove();
}
missing = true;
break;
}
// If any variables are missing, skip this slice
if (v.isMissing(vt)) {
missing = true;
break;
}
}
// keep a list of the falsified invariants
if (!missing) {
while (k.hasNext()) {
Invariant inv = k.next();
Invariant pre_inv = inv.clone();
for (VarInfo vi : inv.ppt.var_infos) {
assert vt.getValue(vi) != null : vi;
}
if (inv.ppt instanceof PptSlice2) assert inv.ppt.var_infos.length == 2;
InvariantStatus status = inv.add_sample(vt, 1);
if (status == InvariantStatus.FALSIFIED) {
k.remove();
}
}
}
// update num_samples and num_values of a slice manually
// because DaikonSimple does not call any of PptTopLevel's
// add methods
for (int j = 0; j < vt.vals.length; j++) {
if (!vt.isMissing(j)) {
ValueSet vs = ppt.value_sets[j];
vs.add(vt.vals[j]);
}
}
ppt.mbtracker.add(vt, 1);
}
}
/**
* Process the sample by checking it against each existing invariant at the program point and
* removing the invariant from the list of possibles if any invariant is falsified.
*/
public void process_sample(
PptMap all_ppts, PptTopLevel ppt, ValueTuple vt, /*@Nullable*/ Integer nonce) {
this.all_ppts = all_ppts;
// Add samples to orig and derived variables
FileIO.add_orig_variables(ppt, vt.vals, vt.mods, nonce);
FileIO.add_derived_variables(ppt, vt.vals, vt.mods);
// Intern the sample
vt = new ValueTuple(vt.vals, vt.mods);
// DaikonSimple must make the object program point manually because
// the new Chicory produced dtrace files do not contain object ppts
// in the dtrace part of the file (the program point is declared).
// Make the object ppt
PptName ppt_name = ppt.ppt_name;
PptTopLevel object_ppt = null;
PptTopLevel class_ppt = null;
ValueTuple object_vt = null;
ValueTuple class_vt = null;
if ((ppt_name.isEnterPoint() && !ppt_name.isConstructor()) || ppt_name.isExitPoint()) {
object_ppt = all_ppts.get(ppt_name.makeObject());
class_ppt = all_ppts.get(ppt_name.makeClassStatic());
}
// C programs do not have object ppts
// check whether the ppt is a static or instance method
// that decides whether the sample is copied over to the object and/or
// class ppt
if (object_ppt != null) {
// the check assumes that static fields are not stored first in the
// object ppt
if (ppt.find_var_by_name(object_ppt.var_infos[0].name()) != null) {
// object and class ppt should be created
object_vt = copySample(object_ppt, ppt, vt, nonce);
if (class_ppt != null) {
class_vt = copySample(class_ppt, ppt, vt, nonce);
}
} else {
// only class ppt should be created
if (class_ppt != null) {
class_vt = copySample(class_ppt, ppt, vt, nonce);
}
object_vt = null;
object_ppt = null;
}
}
// If this is an enter point, just remember it for later
if (ppt_name.isEnterPoint()) {
assert nonce != null;
assert call_map.get(nonce) == null;
List<Call> value = new ArrayList<Call>();
value.add(new Call(ppt, vt));
if (object_ppt != null) {
value.add(new Call(object_ppt, object_vt));
}
if (class_ppt != null) {
value.add(new Call(class_ppt, class_vt));
}
call_map.put(nonce, value);
last_nonce = nonce;
wait = true;
return;
}
// If this is an exit point, process the saved enter (and sometimes
// object) point
if (ppt_name.isExitPoint()) {
assert nonce != null;
List<Call> value = call_map.remove(nonce);
add(ppt, vt, nonce);
for (Call ec : value) {
add(ec.ppt, ec.vt, nonce);
}
wait = false;
}
if (object_ppt != null) add(object_ppt, object_vt, nonce); // apply object vt
if (class_ppt != null) add(class_ppt, class_vt, nonce);
}
/**
* 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.
*
* <p>Difference from Daikon's mainHelper: turn off optimization flags (equality, dynamic
* constants, NIS suppression).
*
* @see #main(String[])
* @see daikon.Daikon.TerminationMessage
* @see daikon.Daikon#mainHelper(String[])
*/
public static void mainHelper(final String[] args) throws IOException, FileNotFoundException {
// set up logging information
daikon.LogHelper.setupLogs(daikon.LogHelper.INFO);
// No optimizations used in the simple incremental algorithm so
// optimizations are turned off.
Daikon.use_equality_optimization = false;
Daikon.dkconfig_use_dynamic_constant_optimization = false;
Daikon.suppress_implied_controlled_invariants = false;
NIS.dkconfig_enabled = false;
// The flag tells FileIO and Daikon to use DaikonSimple
// specific methods (e.g. FileIO.read_declaration_file).
// When FileIO reads and processes
// samples, it must use the SimpleProcessor rather than the
// default Processor.
Daikon.using_DaikonSimple = true;
// Read command line options
Daikon.FileOptions files = Daikon.read_options(args, usage);
// DaikonSimple does not supply nor use the spinfo_files and map_files
Set<File> decls_files = files.decls;
Set<String> dtrace_files = files.dtrace;
if ((decls_files.size() == 0) && (dtrace_files.size() == 0)) {
throw new Daikon.TerminationMessage("No .decls or .dtrace files specified");
}
// Create the list of all invariant types
Daikon.setup_proto_invs();
// Create the program points for enter and numbered exits and
// initializes the points (adding orig and derived variables)
all_ppts = FileIO.read_declaration_files(decls_files);
// Create the combined exits (and add orig and derived vars)
// Daikon.create_combined_exits(all_ppts);
// Read and process the data trace files
SimpleProcessor processor = new SimpleProcessor();
FileIO.read_data_trace_files(dtrace_files, all_ppts, processor, true);
// System.exit(0);
// Print out the invariants for each program point (sort first)
for (Iterator<PptTopLevel> t = all_ppts.pptIterator(); t.hasNext(); ) {
PptTopLevel ppt = t.next();
// We do not need to print out program points that have not seen
// any samples.
if (ppt.num_samples() == 0) {
continue;
}
List<Invariant> invs = PrintInvariants.sort_invariant_list(ppt.invariants_vector());
List<Invariant> filtered_invs = Daikon.filter_invs(invs);
// The dkconfig_quiet printing is used for creating diffs between
// DaikonSimple
// and Daikon's output. The second kind of printing is used for
// debugging. Since the names of the program points are the same for both
// Daikon and DaikonSimple, diffing the two output will result in
// only differences in the invariants, but we can not see at which program
// points these differing invariants appear. Using the second kind of
// printing,
// Daikon's output does not have the '+' in the program point name, so in
// addition
// to the invariants showing up in the diff, we will also see the program
// point
// names.
if (Daikon.dkconfig_quiet) {
System.out.println("====================================================");
System.out.println(ppt.name());
} else {
System.out.println("===================================================+");
System.out.println(ppt.name() + " +");
}
// Sometimes the program points actually differ in number of
// samples seen due to differences in how Daikon and DaikonSimple
// see the variable hierarchy.
System.out.println(ppt.num_samples());
for (Invariant inv : filtered_invs) {
System.out.println(inv.getClass());
System.out.println(inv);
}
}
}
public static void extract_consequent(PptMap ppts) {
// Retrieve Ppt objects in sorted order.
// Use a custom comparator for a specific ordering
Comparator<PptTopLevel> comparator = new Ppt.NameComparator();
TreeSet<PptTopLevel> ppts_sorted = new TreeSet<PptTopLevel>(comparator);
ppts_sorted.addAll(ppts.asCollection());
for (PptTopLevel ppt : ppts_sorted) {
extract_consequent_maybe(ppt, ppts);
}
PrintWriter pw = new PrintWriter(System.out, true);
// All conditions at a program point. A TreeSet to enable
// deterministic output.
TreeSet<String> allConds = new TreeSet<String>();
for (String pptname : pptname_to_conditions.keySet()) {
Map<String, Map<String, HashedConsequent>> cluster_to_conditions =
pptname_to_conditions.get(pptname);
for (Map.Entry</*@KeyFor("cluster_to_conditions")*/ String, Map<String, HashedConsequent>>
entry : cluster_to_conditions.entrySet()) {
String predicate = entry.getKey();
Map<String, HashedConsequent> conditions = entry.getValue();
StringBuffer conjunctionJava = new StringBuffer();
StringBuffer conjunctionDaikon = new StringBuffer();
StringBuffer conjunctionESC = new StringBuffer();
StringBuffer conjunctionSimplify = new StringBuffer("(AND ");
int count = 0;
for (Map.Entry</*@KeyFor("conditions")*/ String, HashedConsequent> entry2 :
conditions.entrySet()) {
count++;
String condIndex = entry2.getKey();
HashedConsequent cond = entry2.getValue();
if (cond.fakeFor != null) {
count--;
continue;
}
String javaStr = cond.inv.format_using(OutputFormat.JAVA);
String daikonStr = cond.inv.format_using(OutputFormat.DAIKON);
String escStr = cond.inv.format_using(OutputFormat.ESCJAVA);
String simplifyStr = cond.inv.format_using(OutputFormat.SIMPLIFY);
allConds.add(combineDummy(condIndex, "<dummy> " + daikonStr, escStr, simplifyStr));
// allConds.add(condIndex);
if (count > 0) {
conjunctionJava.append(" && ");
conjunctionDaikon.append(" and ");
conjunctionESC.append(" && ");
conjunctionSimplify.append(" ");
}
conjunctionJava.append(javaStr);
conjunctionDaikon.append(daikonStr);
conjunctionESC.append(escStr);
conjunctionSimplify.append(simplifyStr);
}
conjunctionSimplify.append(")");
String conj = conjunctionJava.toString();
// Avoid inserting self-contradictory conditions such as "x == 1 &&
// x == 2", or conjunctions of only a single condition.
if (count < 2
|| contradict_inv_pattern.matcher(conj).find()
|| useless_inv_pattern_1.matcher(conj).find()
|| useless_inv_pattern_2.matcher(conj).find()) {
// System.out.println("Suppressing: " + conj);
} else {
allConds.add(
combineDummy(
conjunctionJava.toString(),
conjunctionDaikon.toString(),
conjunctionESC.toString(),
conjunctionSimplify.toString()));
}
}
if (allConds.size() > 0) {
pw.println();
pw.println("PPT_NAME " + pptname);
for (String s : allConds) {
pw.println(s);
}
}
allConds.clear();
}
pw.flush();
}
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++;
}
}
}
}
private static void checkInvariants() throws IOException {
// Read the invariant file
PptMap ppts = FileIO.read_serialized_pptmap(inv_file, true);
// Yoav: make sure we have unique invariants
InvariantFilters fi = InvariantFilters.defaultFilters();
// Set<String> allInvariantsStr = new HashSet<String>();
Set<Invariant> allInvariants = new HashSet<Invariant>();
for (PptTopLevel ppt : ppts.all_ppts())
for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) {
PptSlice slice = i.next();
for (Invariant inv : slice.invs) {
if (doConf && inv.getConfidence() < Invariant.dkconfig_confidence_limit) {
// System.out.printf ("inv ignored (conf): %s:%s\n", inv.ppt.name(),
// inv.format());
continue;
}
if (doFilter && fi.shouldKeep(inv) == null) {
// System.out.printf ("inv ignored (filter): %s:%s\n",
// inv.ppt.name(), inv.format());
continue;
}
activeInvariants.add(inv);
// String n = invariant2str(ppt, inv);
// if (!allInvariants.contains(inv) && allInvariantsStr.contains(n)) throw new
// Daikon.TerminationMessage("Two invariants have the same ppt.name+inv.rep:"+n);
allInvariants.add(inv);
// allInvariantsStr.add(n);
}
}
// Read and process the data trace files
FileIO.Processor processor = new InvariantCheckProcessor();
Daikon.FileIOProgress progress = new Daikon.FileIOProgress();
progress.start();
progress.clear();
FileIO.read_data_trace_files(dtrace_files, ppts, processor, false);
progress.shouldStop = true;
System.out.println();
System.out.printf(
"%s: %,d errors found in %,d samples (%s)\n",
inv_file, error_cnt, sample_cnt, toPercentage(error_cnt, sample_cnt));
int failedCount = failedInvariants.size();
int testedCount = testedInvariants.size();
String percent = toPercentage(failedCount, testedCount);
System.out.println(
inv_file
+ ": "
+ failedCount
+ " false positives, out of "
+ testedCount
+ ", which is "
+ percent
+ ".");
if (false) {
for (Invariant inv : failedInvariants) {
System.out.printf("+%s:%s\n", inv.ppt.name(), inv.format());
}
}
}
