/** * Displays the negative tree properties and the currently known properties. */ void graph_t::show_negative() const { preal_set ps; for (std::list<logic_node *>::const_iterator i = trees.begin(), i_end = trees.end(); i != i_end; ++i) { find_negative(ps, (*i)->tree); } if (ps.empty()) { std::cerr << "Error: no contradiction was found.\n"; return; } std::cerr << "Error: some properties were not satisfied:\n"; for (preal_set::const_iterator i = ps.begin(), i_end = ps.end(); i != i_end; ++i) { std::cerr << " " << dump_real(*i); if (node *n = find_already_known(*i)) { std::cerr << ", best: "; if (i->pred_bnd()) std::cerr << n->get_result().bnd(); else std::cerr << n->get_result().cst(); } std::cerr << '\n'; } }
// 0: no rule, 1: a rule but a missing relation, 2: a rule int test_rewriting(ast_real const *src, ast_real const *dst, std::string &res) { std::ostringstream info; for(rewriting_vect::const_iterator i = rewriting_rules.begin(), i_end = rewriting_rules.end(); i != i_end; ++i) { rewriting_rule const &rw = **i; if (rw.src.pred() != PRED_BND) continue; ast_real_vect holders; if (!match(src, rw.src.real(), holders)) continue; bool b = holders.size() >= 2 && (!holders[0] || !holders[1]); if (!match(dst, rw.dst.real(), holders, true)) continue; for(pattern_excl_vect::const_iterator j = rw.excl.begin(), j_end = rw.excl.end(); j != j_end; ++j) if (rewrite(j->first, holders) == rewrite(j->second, holders)) goto next_rule; if (b) { assert(holders[0] && holders[1]); link_map::const_iterator k = approximates.find(holders[0]); if (k != approximates.end() && k->second.find(holders[1]) != k->second.end()) goto found_rule; info << " " << dump_real(holders[1]) << " ~ " << dump_real(holders[0]) << '\n'; } else { found_rule: info.str(std::string()); for(pattern_cond_vect::const_iterator j = rw.cond.begin(), j_end = rw.cond.end(); j != j_end; ++j) { info << " " << dump_real(rewrite(j->real, holders)); char const *ops[] = { " < ", " <= ", " > ", " >= ", " != " }; if (j->type == COND_NZ) info << " != 0 "; else info << ops[j->type] << j->value; info << '\n'; } res = info.str(); return 2; } next_rule: ; } res = info.str(); return !res.empty(); }
void dump_chunk(Chunk *chunk, FILE *fp) { // TODO - may be wasteful, check size limits dump_int(fp, chunk->numtemps); dump_int(fp, chunk->numconstants); dump_int(fp, chunk->numinstructions); dump_int(fp, chunk->numchildren); dump_int(fp, chunk->numlocals); dump_int(fp, chunk->numupvars); dump_int(fp, chunk->numparams); int i; for (i = 0; i < chunk->numinstructions; i++) { dump_int(fp, chunk->instructions[i]); } for (i = 0; i < chunk->numconstants; i++) { // TODO - wasteful, doesn't need nearly 32 bits dump_int(fp, chunk->constants[i]->type); switch (chunk->constants[i]->type) { case CONST_INT: case CONST_BOOL: dump_int(fp, chunk->constants[i]->value.i); break; case CONST_REAL: dump_real(fp, chunk->constants[i]->value.d); break; case CONST_NULL: break; case CONST_STRING: { dump_string(fp, chunk->constants[i]->value.s); } break; } } for (i = 0; i < chunk->numchildren; i++) { dump_chunk(chunk->children[i], fp); } }
void dump_real(symbolTable *st, int depth){ // Visit all slots and traverse all buckets in the chain, and print all data contained. int i; char padding[256]; bucket *cur; for(i = 0; i<depth; i++) padding[i] = '\t'; padding[i] = '\0'; for(i = 0; i< TABLE_SIZE ; i++){ cur = st->table[i].link; while(cur != NULL){ fprintf(stdout, "%s", padding, i); printElement(cur->inner); if(cur->inner.subRegion != NULL) dump_real(cur->inner.subRegion, depth+1); cur = cur->link; } } }
static void dequeue_and_dump (dump_info_p di) { dump_queue_p dq; splay_tree_node stn; dump_node_info_p dni; tree t; unsigned int index; enum tree_code code; enum tree_code_class code_class; const char* code_name; /* Get the next node from the queue. */ dq = di->queue; stn = dq->node; t = (tree) stn->key; dni = (dump_node_info_p) stn->value; index = dni->index; /* Remove the node from the queue, and put it on the free list. */ di->queue = dq->next; if (!di->queue) di->queue_end = 0; dq->next = di->free_list; di->free_list = dq; /* Print the node index. */ dump_index (di, index); /* And the type of node this is. */ if (dni->binfo_p) code_name = "binfo"; else code_name = tree_code_name[(int) TREE_CODE (t)]; fprintf (di->stream, "%-16s ", code_name); di->column = 25; /* Figure out what kind of node this is. */ code = TREE_CODE (t); code_class = TREE_CODE_CLASS (code); /* Although BINFOs are TREE_VECs, we dump them specially so as to be more informative. */ if (dni->binfo_p) { unsigned ix; tree base; VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t); dump_child ("type", BINFO_TYPE (t)); if (BINFO_VIRTUAL_P (t)) dump_string_field (di, "spec", "virt"); dump_int (di, "bases", BINFO_N_BASE_BINFOS (t)); for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++) { tree access = (accesses ? VEC_index (tree, accesses, ix) : access_public_node); const char *string = NULL; if (access == access_public_node) string = "pub"; else if (access == access_protected_node) string = "prot"; else if (access == access_private_node) string = "priv"; else gcc_unreachable (); dump_string_field (di, "accs", string); queue_and_dump_index (di, "binf", base, DUMP_BINFO); } goto done; } /* We can knock off a bunch of expression nodes in exactly the same way. */ if (IS_EXPR_CODE_CLASS (code_class)) { /* If we're dumping children, dump them now. */ queue_and_dump_type (di, t); switch (code_class) { case tcc_unary: dump_child ("op 0", TREE_OPERAND (t, 0)); break; case tcc_binary: case tcc_comparison: dump_child ("op 0", TREE_OPERAND (t, 0)); dump_child ("op 1", TREE_OPERAND (t, 1)); break; case tcc_expression: case tcc_reference: case tcc_statement: case tcc_vl_exp: /* These nodes are handled explicitly below. */ break; default: gcc_unreachable (); } } else if (DECL_P (t)) { expanded_location xloc; /* All declarations have names. */ if (DECL_NAME (t)) dump_child ("name", DECL_NAME (t)); if (DECL_ASSEMBLER_NAME_SET_P (t) && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t)) dump_child ("mngl", DECL_ASSEMBLER_NAME (t)); if (DECL_ABSTRACT_ORIGIN (t)) dump_child ("orig", DECL_ABSTRACT_ORIGIN (t)); /* And types. */ queue_and_dump_type (di, t); dump_child ("scpe", DECL_CONTEXT (t)); /* And a source position. */ xloc = expand_location (DECL_SOURCE_LOCATION (t)); if (xloc.file) { const char *filename = lbasename (xloc.file); dump_maybe_newline (di); fprintf (di->stream, "srcp: %s:%-6d ", filename, xloc.line); di->column += 6 + strlen (filename) + 8; } /* And any declaration can be compiler-generated. */ if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON) && DECL_ARTIFICIAL (t)) dump_string_field (di, "note", "artificial"); if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL)) dump_child ("chain", DECL_CHAIN (t)); } else if (code_class == tcc_type) { /* All types have qualifiers. */ int quals = lang_hooks.tree_dump.type_quals (t); if (quals != TYPE_UNQUALIFIED) { fprintf (di->stream, "qual: %c%c%c ", (quals & TYPE_QUAL_CONST) ? 'c' : ' ', (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ', (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' '); di->column += 14; } /* All types have associated declarations. */ dump_child ("name", TYPE_NAME (t)); /* All types have a main variant. */ if (TYPE_MAIN_VARIANT (t) != t) dump_child ("unql", TYPE_MAIN_VARIANT (t)); /* And sizes. */ dump_child ("size", TYPE_SIZE (t)); /* All types have alignments. */ dump_int (di, "algn", TYPE_ALIGN (t)); } else if (code_class == tcc_constant) /* All constants can have types. */ queue_and_dump_type (di, t); /* Give the language-specific code a chance to print something. If it's completely taken care of things, don't bother printing anything more ourselves. */ if (lang_hooks.tree_dump.dump_tree (di, t)) goto done; /* Now handle the various kinds of nodes. */ switch (code) { int i; case IDENTIFIER_NODE: dump_string_field (di, "strg", IDENTIFIER_POINTER (t)); dump_int (di, "lngt", IDENTIFIER_LENGTH (t)); break; case TREE_LIST: dump_child ("purp", TREE_PURPOSE (t)); dump_child ("valu", TREE_VALUE (t)); dump_child ("chan", TREE_CHAIN (t)); break; case STATEMENT_LIST: { tree_stmt_iterator it; for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++) { char buffer[32]; sprintf (buffer, "%u", i); dump_child (buffer, tsi_stmt (it)); } } break; case TREE_VEC: dump_int (di, "lngt", TREE_VEC_LENGTH (t)); for (i = 0; i < TREE_VEC_LENGTH (t); ++i) { char buffer[32]; sprintf (buffer, "%u", i); dump_child (buffer, TREE_VEC_ELT (t, i)); } break; case INTEGER_TYPE: case ENUMERAL_TYPE: dump_int (di, "prec", TYPE_PRECISION (t)); dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); dump_child ("min", TYPE_MIN_VALUE (t)); dump_child ("max", TYPE_MAX_VALUE (t)); if (code == ENUMERAL_TYPE) dump_child ("csts", TYPE_VALUES (t)); break; case REAL_TYPE: dump_int (di, "prec", TYPE_PRECISION (t)); break; case FIXED_POINT_TYPE: dump_int (di, "prec", TYPE_PRECISION (t)); dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); dump_string_field (di, "saturating", TYPE_SATURATING (t) ? "saturating": "non-saturating"); break; case POINTER_TYPE: dump_child ("ptd", TREE_TYPE (t)); break; case REFERENCE_TYPE: dump_child ("refd", TREE_TYPE (t)); break; case METHOD_TYPE: dump_child ("clas", TYPE_METHOD_BASETYPE (t)); /* Fall through. */ case FUNCTION_TYPE: dump_child ("retn", TREE_TYPE (t)); dump_child ("prms", TYPE_ARG_TYPES (t)); break; case ARRAY_TYPE: dump_child ("elts", TREE_TYPE (t)); dump_child ("domn", TYPE_DOMAIN (t)); break; case RECORD_TYPE: case UNION_TYPE: if (TREE_CODE (t) == RECORD_TYPE) dump_string_field (di, "tag", "struct"); else dump_string_field (di, "tag", "union"); dump_child ("flds", TYPE_FIELDS (t)); dump_child ("fncs", TYPE_METHODS (t)); queue_and_dump_index (di, "binf", TYPE_BINFO (t), DUMP_BINFO); break; case CONST_DECL: dump_child ("cnst", DECL_INITIAL (t)); break; case DEBUG_EXPR_DECL: dump_int (di, "-uid", DEBUG_TEMP_UID (t)); /* Fall through. */ case VAR_DECL: case PARM_DECL: case FIELD_DECL: case RESULT_DECL: if (TREE_CODE (t) == PARM_DECL) dump_child ("argt", DECL_ARG_TYPE (t)); else dump_child ("init", DECL_INITIAL (t)); dump_child ("size", DECL_SIZE (t)); dump_int (di, "algn", DECL_ALIGN (t)); if (TREE_CODE (t) == FIELD_DECL) { if (DECL_FIELD_OFFSET (t)) dump_child ("bpos", bit_position (t)); } else if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL) { dump_int (di, "used", TREE_USED (t)); if (DECL_REGISTER (t)) dump_string_field (di, "spec", "register"); } break; case FUNCTION_DECL: dump_child ("args", DECL_ARGUMENTS (t)); if (DECL_EXTERNAL (t)) dump_string_field (di, "body", "undefined"); if (TREE_PUBLIC (t)) dump_string_field (di, "link", "extern"); else dump_string_field (di, "link", "static"); if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t)) dump_child ("body", DECL_SAVED_TREE (t)); break; case INTEGER_CST: if (TREE_INT_CST_HIGH (t)) dump_int (di, "high", TREE_INT_CST_HIGH (t)); dump_int (di, "low", TREE_INT_CST_LOW (t)); break; case STRING_CST: fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t)); dump_int (di, "lngt", TREE_STRING_LENGTH (t)); break; case REAL_CST: dump_real (di, "valu", TREE_REAL_CST_PTR (t)); break; case FIXED_CST: dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t)); break; case TRUTH_NOT_EXPR: case ADDR_EXPR: case INDIRECT_REF: case CLEANUP_POINT_EXPR: case SAVE_EXPR: case REALPART_EXPR: case IMAGPART_EXPR: /* These nodes are unary, but do not have code class `1'. */ dump_child ("op 0", TREE_OPERAND (t, 0)); break; case TRUTH_ANDIF_EXPR: case TRUTH_ORIF_EXPR: case INIT_EXPR: case MODIFY_EXPR: case COMPOUND_EXPR: case PREDECREMENT_EXPR: case PREINCREMENT_EXPR: case POSTDECREMENT_EXPR: case POSTINCREMENT_EXPR: /* These nodes are binary, but do not have code class `2'. */ dump_child ("op 0", TREE_OPERAND (t, 0)); dump_child ("op 1", TREE_OPERAND (t, 1)); break; case COMPONENT_REF: dump_child ("op 0", TREE_OPERAND (t, 0)); dump_child ("op 1", TREE_OPERAND (t, 1)); dump_child ("op 2", TREE_OPERAND (t, 2)); break; case ARRAY_REF: case ARRAY_RANGE_REF: dump_child ("op 0", TREE_OPERAND (t, 0)); dump_child ("op 1", TREE_OPERAND (t, 1)); dump_child ("op 2", TREE_OPERAND (t, 2)); dump_child ("op 3", TREE_OPERAND (t, 3)); break; case COND_EXPR: dump_child ("op 0", TREE_OPERAND (t, 0)); dump_child ("op 1", TREE_OPERAND (t, 1)); dump_child ("op 2", TREE_OPERAND (t, 2)); break; case TRY_FINALLY_EXPR: dump_child ("op 0", TREE_OPERAND (t, 0)); dump_child ("op 1", TREE_OPERAND (t, 1)); break; case CALL_EXPR: { int i = 0; tree arg; call_expr_arg_iterator iter; dump_child ("fn", CALL_EXPR_FN (t)); FOR_EACH_CALL_EXPR_ARG (arg, iter, t) { char buffer[32]; sprintf (buffer, "%u", i); dump_child (buffer, arg); i++; } } break; case CONSTRUCTOR: { unsigned HOST_WIDE_INT cnt; tree index, value; dump_int (di, "lngt", VEC_length (constructor_elt, CONSTRUCTOR_ELTS (t))); FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value) { dump_child ("idx", index); dump_child ("val", value); } }
symbolTable *dump(symbolTable *st){ // Visit all slots and traverse all buckets in the chain, and print all data contained. fprintf(stdout, "\033[38;5;45m*** Symbol table ***\033[0;0m\r\n"); // \033 is for the console color. For more information please refer to https://en.wikipedia.org/wiki/ANSI_escape_code#Colors dump_real(st, 0); fprintf(stdout, "\033[38;5;45m*** End symbol table ***\033[0;0m\r\n"); return st; }
int main(int argc, char **argv) { long long start_time, end_time; PAPI_library_init(PAPI_VER_CURRENT); start_time = PAPI_get_real_usec(); parse_args_status pargs_status = parse_args(argc, argv); if (pargs_status != PARGS_CONTINUE) return pargs_status == PARGS_FAILURE ? EXIT_FAILURE : EXIT_SUCCESS; if (proof_generator) { if (!parameter_constrained) { std::cerr << "Error: unconstrained mode is not compatible with script generation, since proofs are left incomplete.\n"; return EXIT_FAILURE; } proof_generator->initialize(std::cout); } if (yyparse()) return EXIT_FAILURE; preal_vect missing_paths = generate_proof_paths(); for (preal_vect::const_iterator i = missing_paths.begin(), i_end = missing_paths.end(); i != i_end; ++i) { std::cerr << "Warning: no path was found for " << dump_real(*i) << ".\n"; } bool globally_proven = true; undefined_map umap; graph_t *g = new graph_t(NULL, context); g->populate(property_tree(), dichotomies, 100*1000*1000, &umap); if (!umap.empty()) { std::cerr << "Results:\n"; for (undefined_map::const_iterator i = umap.begin(), i_end = umap.end(); i != i_end; ++i) { change_io_format dummy(IO_APPROX); std::cerr << " " << dump_property_nice(i->second) << '\n'; } } if (node *n = g->get_contradiction()) { if (proof_generator) { enlarger(node_vect(1, n)); instances = &umap; proof_generator->theorem(n); } } else { g->show_negative(); globally_proven = false; } g->show_dangling(); delete g; if (proof_generator) proof_generator->finalize(); if (parameter_statistics) { std::cerr << "Statistics:\n" " " << stat_tested_real << " expressions were considered,\n" " but then " << stat_discarded_real << " of those got discarded.\n" " " << stat_tested_theo << " theorems were considered,\n" " but then " << stat_discarded_theo << " of those got discarded.\n" " " << stat_tested_app << " applications were tried. Among those,\n" " " << stat_successful_app << " were successful,\n" " yet " << stat_discarded_pred << " proved useless\n" " and " << stat_intersected_pred << " improved existing results.\n"; } // PAPI time measure, added by Deheng end_time = PAPI_get_real_usec(); std::cerr << "Time measured by PAPI is : " << end_time - start_time << " us" << std::endl; return globally_proven ? EXIT_SUCCESS : EXIT_FAILURE; }