EP1706833B1 - System and method for modeling, abstraction, and analysis of software - Google Patents

System and method for modeling, abstraction, and analysis of software Download PDF

Info

Publication number
EP1706833B1
EP1706833B1 EP20050705999 EP05705999A EP1706833B1 EP 1706833 B1 EP1706833 B1 EP 1706833B1 EP 20050705999 EP20050705999 EP 20050705999 EP 05705999 A EP05705999 A EP 05705999A EP 1706833 B1 EP1706833 B1 EP 1706833B1
Authority
EP
European Patent Office
Prior art keywords
software program
method
program
variables
set
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Expired - Fee Related
Application number
EP20050705999
Other languages
German (de)
French (fr)
Other versions
EP1706833A2 (en
EP1706833A4 (en
Inventor
Franjo Ivancic
Pranav N. Ashar
Malay K. Ganai
Aarti Gupta
Zijiang Yang
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
NEC Corp
Original Assignee
NEC Laboratories America Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority to US53852404P priority Critical
Application filed by NEC Laboratories America Inc filed Critical NEC Laboratories America Inc
Priority to US11/040,409 priority patent/US7346486B2/en
Priority to PCT/US2005/001963 priority patent/WO2005072257A2/en
Publication of EP1706833A2 publication Critical patent/EP1706833A2/en
Publication of EP1706833A4 publication Critical patent/EP1706833A4/en
Application granted granted Critical
Publication of EP1706833B1 publication Critical patent/EP1706833B1/en
Application status is Expired - Fee Related legal-status Critical
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/50Computer-aided design
    • G06F17/5009Computer-aided design using simulation
    • G06F17/504Formal methods
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00Error detection; Error correction; Monitoring
    • G06F11/36Preventing errors by testing or debugging software
    • G06F11/3604Software analysis for verifying properties of programs
    • G06F11/3608Software analysis for verifying properties of programs using formal methods, e.g. model checking, abstract interpretation

Abstract

A system and method is disclosed for formal verification of software that advantageously translates the software (101), which can have bounded recursion, into a Boolean representation (130) comprised of basic blocks and which applies SAT-based model checking (150) to the Boolean representation.

Description

    BACKGROUND OF THE INVENTION
  • The present invention is related to techniques for formal analysis and verification of software.
  • Model checking is an automatic technique for the verification of concurrent systems. It has several advantages over simulation, testing, and deductive reasoning, and has been used successfully in practice to verify complex sequential circuit designs and communication protocols. See E.M. Clarke, O. Grumberg, and D.A. Peled, "Model Checking," MIT Press, 2000. In particular, model checking is automatic, and, if the design contains an error, model checking produces a counter-example (i.e., a witness of the offending behavior of the system) that can be used for effective debugging of the system. While symbolic model checking using binary decision diagrams (BDDs) offer the potential of exhaustive coverage of large state-spaces, it often does not scale well enough in practice. An alternative approach is bounded model checking (BMC) focusing on the search for counter-examples of bounded length only. See A. Biere, A. Cimatti, E.M Clarke, M. Fujita, and Y. Zhu, "Symbolic model checking using SAT procedures instead of BDDs," Proc. of the 36th ACM/IEEE Design Automation Conference, pp. 317-20 (1999). Effectively, the problem is translated to a Boolean formula, such that the formula is satisfiable if and only if there exists a counter-example of length k. In practice, k can be increased incrementally starting from one to find a shortest counter-example if one exists. However, additional reasoning is needed to ensure completeness of the verification when no couuter-example exists. The satisfiability check in the BMC approach is typically performed by what is known as a back-end SAT-solver. See, e.g., MK. Ganai, L Zhang, P. Ashar, and A Gupta, "Combining strength of circuit-based and CNF-based algorithms for a high performance SAT solver," in Design Automation Conference, 2002; E. Goldberg and Y. Novikov, "Berkmin: A fast and robust SAT solver," in Design Automation and Test in Europe, pages 132-39,2002; J.P. Marques-Silva and K.A Sakallah, "GRASP: A search algorithm for prepositional satisfiability," IEEE Transactions on Computers, 48:506-21, 1999; and M. Moskewicz, C. Madigan, Y. Zhao, L. Zhang, and S. Malik, "Chaff: Enginnering an efficient SAT solver," in Design Automation Conference, 2001.
  • Recently, it has been proposed to apply bounded model checking techniques to the formal verification of software such as C programs. See E. Clarke, D. Kroening, "Hardware Verification using ANSI-C Programs as a Reference," Proceedings of ASP-DAC 2003, pp. 308-11 (January 2003). In this approach, a C program is translated into a monolithic SAT formula, namely a bit vector equation, which is then used with SAT-based bounded model checking to check consistency properties, including checking the equivalence of the C program to a register-transfer level (RTL) hardware design. Each individual statement in the C program is considered to be an atomic component of the program. Unfortunately, this statement-based approach has limitations in terms of concisely handling loops and functions and does not take full advantage of recent advances in model checking.
  • Prior art document US 2003/0204834 A1 provides a method that enables the automatic generation of a boolean program that is a predicate abstraction of a program written using a general programming language. The method is capable of abstracting code statements within the program that include procedure calls, assignments, goto statements, conditionals, and pointers. In accordance with the invention, predicates of interest are identified for each code statement in the program. For each particular code statement, the process generates predicate statements that describe an effect that the statement has on the predicates of interest. If the effect of a particular code statement is indeterminable, nondeterministic predicate statements are included in the boolean program to model the indeterminable nature of the code statement. In addition, if a particular code statement includes a procedure call, the arguments and return value of the procedure call are translated to associated predicates in the calling context.
  • SUMMARY OF INVENTION
  • A verification system and method for software is disclosed which advantageously translates a software program into a Boolean representation based on one or more basic blocks. Rather than dealing with individual statements as the atomic components of the software program, each basic block can represent a sequence of instructions in the software program as a set of parallel assignments and a set of transitions to other basic blocks. Then, a model checker, such as a back-end SAT solver that uses bounded model checking, can be applied to the Boolean representation. The model checker proceeds by iteratively unrolling the basic blocks, each unrolling understood to be one step in a block-wise execution of the software program. The state of the system can be defined to contain a location indicating the current active basic block and the evaluation of all variables in scope. Thus, a label can be generated for each basic block and a program counter variable introduced to track progress of allowed executions of the software program during the model checking. Each unrolling of a basic block by the model checker advantageously has a limited number of successors. Although each unrolling introduces the whole software program into the satisfiability problem of the model checker, many basic blocks in the new unrolling can be declared unreachable by purely considering the control flow of the software program. Thus, knowledge of the model generation process can be incorporated into the decision heuristics used by the model checker to further improve the efficiency of the verification.
  • The software program can be abstracted in a manner that advantageously contains both abstracted and concrete data variables. This allows a seamless tradeoff between accuracy and easy of analysis, potentially enabling accurate analysis with a fewer number of abstraction-refinement iterations. The use of predicate abstraction for the analysis of the software can be improved by computing the transition relations amongst basic blocks using symbolic predicate abstraction and the use of approximate transition relations. The combination of the two approaches, as well as the inclusion of heuristics to compute the many transition relations found in a whole software program more efficiently by proper scheduling of computations and memorizing of partial results, results in a more efficient approach to computing the transition relations.
  • Code simplification can be applied automatically in a manner that does not affect the semantics of the program. Range analysis can be performed prior to modeling in order to limit the size of the variables in the Boolean representation of the software program. Program slicing can be performed to decompose the software program into semantically meaningful decompositions where the elements are not necessarily textual continuous.
  • Refinement analysis based on spurious transitions, fragments and full paths can be used in an efficient manner by keeping the learnt clauses persistent during the abstraction-refinement iterative loop, promising a more efficient implementation of a counter-example-guided abstraction refinement framework.
  • The verification system and method disclosed herein provides for faster and more efficient operation and is applicable to a wider range of software applications than in the prior art. These and other advantages of the invention will be apparent to those of ordinary skill in the art by reference to the following detailed description and the accompanying drawings.
  • BRIEF DESCRIPTION OF DRAWINGS
  • FIG. 1 shows an abstract diagram illustrating the processing performed on a software program in accordance with an embodiment of the present invention.
  • FIG. 2 is pseudo-code for constructing basic blocks from a software program.
  • FIG. 3 is pseudo-code for constructing basic blocks from a software program which includes non-recursive function calls.
  • FIG. 4 is example C code that shows the control flow information generated for the code.
  • FIG. 5 is another example of C code with a control flow graph generated for the code.
  • FIG. 6 is a truth table for the control logic.
  • FIG. 7 is pseudo-code for constructing combinational circuits to obtain the variable assignment logic.
  • DETAILED DESCRIPTION
  • FIG. 1 is an abstract diagram illustrating the operation of a verification system, in accordance with an embodiment of the present invention. The input to the system is a software program 101 and a representation 105 of the property to be checked. The output of the system is a result that either proves that the software program 101 satisfies the property at 191 or provides a counter-example that disproves the property at 192 (or the analysis can terminate without a conclusive result due to resource constraints such as a time-out or memory exhaustion).
  • The software program 101 to be analyzed can be input as a source code file or a set of source code files written in a programming language, such as the C programming language. The present invention shall be described herein with particular reference to a subset of the C programming language allowing bounded recursion, although the present invention is not limited to C and may readily be extended by one of ordinary skill in the art to other programming languages. The property representation 105 to be checked can come from a variety of sources and be specified in a number of different ways. For example, and without limitation, an advantageous property to check is reachability, i.e. whether a particular part of the source code is reachable. An advantageous mechanism for specifying the property is by modifying the source code to include a property monitor 105, namely a small portion of code that monitors the selected property for the system. Where reachability properties are involved, for example, the property monitor 105 can be provided by a label such as "ERROR_LABEL:" at the line of source code that is to be analyzed for reachability. The process of constructing the property monitor 105 can be readily automated by using, for example, a script. FIG. 1 assumes, without limitation, that the property to be checked is a reachability property.
  • The system performs an automated analysis of the software program, in the form of a static analysis 110, a modeling step 120, and an abstraction step 130, which are further described below. The result is a translation of the program into a Boolean representation that can be analyzed by a back-end model checker at 150.
  • In accordance with an embodiment of an aspect of the invention, the software program 101 is translated by the system into one or more "basic blocks." Rather than dealing with individual statements as the atomic components of the software program, as done in the prior art, each basic block of the software can contain a series of sequential instructions from the software program. A basic block can represent a (possibly empty) set of assignments followed by a (possibly empty) set of guarded (conditional) transitions leading to other basic blocks. By grouping the sequential assignments into a single basic block, these instructions can be rewritten into a set of parallel assignments. This can be accomplished, for example, by replacing certain variables appearing on the left-hand side of an assignment of an instruction inside a basic block with the expression that it was assigned previously in the same basic block if such an assignment occurs as a previous instruction in the basic block. The state of the system can be advantageously defined to contain a location indicating the current active basic block and the evaluation of all variables in scope. A bounded-length stack (per process) can be added to the set of global variables to model a function call stack, which allows modeling of bounded recursion.
  • The model checking of the Boolean representation of the software program, at 150 in FIG. 1, proceeds by unrolling the basic blocks, rather than the individual statements of the software program. A label can be generated for each basic block, and a program counter variable can be introduced to monitor the progress in the state transition graph composed of the basic blocks. The program counter variable can be used to track progress of the allowed executions of the software program during the model checking. An unrolling during the model checking is understood to be one step in a block-wise execution of the software program. In the context of bounded model checking, this is an efficient way of processing the software program, since, for each basic block, there are only a limited number of possible successors. Given a single initial block label, there is only a limited number of possible next blocks reachable in new unrollings. Although each unrolling introduces the whole software program into the satisfiability problem, many blocks in the new unrolling can be declared unreachable by merely considering the control flow of the software program. Thus, the search space can be pruned considerably.
  • Moreover, the model checking at 150 in FIG. 1 can proceed in a manner that incorporates knowledge of the model generation process into the decision heuristics. The program counter variable can be used by the model checker to eliminate many unreachable basic blocks in new unrollings, thereby increasing the likelihood that the model checker can decide based on the program counter variable.
  • FIG. 1, as stated above, assumes that the property checked by the model checker 150 is a reachability property. If the model checker 150 proves that the specified section of the software program 101 is not reachable in the abstracted Boolean representation, it is guaranteed that the section is not reachable in the original source code for the software program 101-thus, ending the verification procedure at 191 in FIG. 1. If the model checker 150 discovers a counter-example, a check is made at 160 to see if the counter-example is spurious. If the analysis of the counter-example at 160 determines that the path is actually feasible in the original software program, a concrete counter-example has been discovered-thereby, ending the verification procedure at 192 in FIG. 1. Otherwise, the Boolean representation is refined at 170 in order to obtain a new representation for the model checker 150.
  • Although the present invention is not limited to any specific model checking architecture, it is advantageous to use a Boolean verification framework that utilizes advanced SAT-based and BDD-based methods for performing both bounded and unbounded verification. An example of such a system is the DiVER system, which is described in United States Utility Patent Application, Serial No. 10/157,486 , entitled "EFFICIENT APPROACHES FOR BOUNDED MODEL CHECKING," filed on May 30, 2002, and Aarti Gupta, Malay K. Ganai, Zijiang Yang, and Pranav Ashar, "Iterative Abstraction using SAT-based BMC with Proof Analysis," In Proceedings of International Conference on Computer-Aided Design (ICCAD), pp.416-423 (Nov. 2003), which are incorporated by reference herein.
  • With reference to FIG. 1, the processing involved in the static analysis 110, the modeling 120, and the abstraction 130 are further described in detail below. Also, the process of analyzing for spurious counter-examples at 170 and refinement at 180 are further described in detail below.
  • STATIC ANALYSIS. It is preferable to perform some code simplification before further processing of the software 101. For example, it can be advantageous to remove nested or embedded function calls inside other function calls by adding temporary variables. It can also be advantageous to rewrite statements with side-effects into equivalent code that does not contain statements with side-effects. See G.C. Necula, S. McPeak, S.P. Rahul, and W. Weimer, "CIL: Intermediate Language and Tools for Analysis and Transformation of C Programs," Proceedings of the 11th International Conference on Computer Construction, LNCS, pp. 213-28, Springer-Verlag (2002).
  • As depicted in FIG. 1, a static analysis 110 is performed on the software. At 111, a control flow graph of the software is computed which is used in the subsequent processing for the modeling of the software. During construction of the control flow graph, it is preferable that variables be renamed to have a unique name for the entire software program, allowing all variables to be treated as globally defined. It is also preferable to flatten out recursive data structures, for example by specifying a bound on the length of such data structures, in order to guarantee a finite model that can be used for analysis purposes.
  • In accordance with another aspect of the invention, it is also advantageous to perform pre-processing such as program slicing 112 and range analysis 113 as part of the analysis framework. A "slice" of a program with respect to a set of program elements is a projection of the program that includes only program elements that might somehow affect the values of variables used at members of the considered set of program elements. See F. Tip, "A Survey of Program Slicing Techniques," Journal of Programming Languages, Vol.3, No.3, pp.121-189 (Sept. 1995). Slicing, thus, allows the system to find a semantically meaningful decomposition of the program where the decompositions consist of elements that are not necessarily textually continuous. Range analysis techniques can also be used to limit the number of bits needed to represent the various statements in the software. See R Rugina and M. C. Rinard, "Symbolic Bounds Analysis of Pointers, Array Indices, and Accessed Memory Regions," SIGPLAN Conference on Programming Language Design and Implementation," pp. 182-95 (2000).
  • MODELING. As depicted in FIG. 1, the modeling 120 of the software considers two kinds of logic: control logic 121 and data logic 122. The control logic 121 describes the flow of control that can be represented by a control flow graph of the basic blocks. The data logic 122 describes the assignments of variables given finite ranges. Assuming the software program consists of N basic blocks, each basic block can be represented by a label of [log N] bits. A program counter variable of [log N] bits can be introduced to monitor progress in the graph of the basic blocks. The control logic defines the transition relation for this program counter variable given the basic block graph and the conditions guarding some of the transitions between the basic blocks. The transitions, thus, model transfer of control within the basic block graph representing the software program. The program counter variable can be used to track progress of allowed executions of the software program during the model checking phase. Each basic block of the source code can be replaced by a tight bit-blasted version of the data variables as well as the control logic given the aforementioned program counter variable and the basic block labels.
  • Similar modeling approaches have been explored in prior art software model checking tools (such as Verisoft, Java Pathfinder, and Bogor), but limited to a non-bounded model checking setting. The software modeling is herein described in a manner that takes advantage of recent progress in SAT-based bounded model checking, while also improving the efficiency of software verification by customizing the back-end model checker.
  • As discussed above, each basic block contains a (possibly empty) set of assignments with a (possibly empty) set of guarded (conditional) transitions leading to other basic blocks. The basic block can be structured more formally as follows. The set of all variables in the program is denoted by X. A type-consistent evaluation of all variables in X is denoted by x, and the set of all type-consistent evaluations is denoted by χ, while the set of allowed C-expressions is represented by Σ. Then, the parallel assignments of a basic block can be written as v 1, ... , v ne 1, ... , en , where V = {v 1, ... , v n} ⊆ X and E = {e 1, ... , en } ⊆ Σ. The set V can be referred to as the assignment set of the block. The set of locally active variables of a basic block l can be denoted as Xl and the set of type-consistent evaluations with χ l. A function Vars : Σ → 2 X denotes the set of variables that occur in a C-expression σΣ using Vars(σ). The set Vars(σ) ⊆ X includes variables that correspond to pointers, pointers of pointers, etc., of variables mentioned in σ as well as address dereferences. This function is generalized naturally to Vars : 2 Σ → 2 X as Vars(E) = Uε∈E Vars(e). For a particular C-block with assignment set VX the set of required variables R can then be defined as R = Vars(E) and the set of unused variables U as U = X \ (Vars(V) ∪ R).
  • In this framework, a state of the program can be defined to comprise a location l E L describing the current basic block and a type-consistent evaluation of data variables x ∈ χ l where out-of-scope variables at location l are assigned the undefined value ⊥. The set of initial states is Q 0 = {(l 0, x)|x ∈ χ l 0 } where the initial state of the program is considered to be completely random in a single location l 0 where each variable in X can take a value that is type-consistent with its specification. A bounded-length stack (per process) can be added to the set of global variables to model a function call stack, thereby allowing modeling of bounded recursion.
  • Control Logic. The control flow graph for the software program is a finite graph G = (L, E) where L consists of basic blocks/locations and E denotes the edges between basic blocks representing transfer of control. Except the first and last instruction, the instructions in each basic block have a unique predecessor and successor. FIG. 2 sets forth pseudo-code for the construction of basic blocks for some programming statements such as if, goto, etc. The main function CREATE_BASIC_BLKS is recursive. The first parameter entry_blk is the entry block to the current statement. The second parameter statement is the current statement. Depending on its type, statement may or may not become part of entry_blk. The function returns a set called exit which consists of pairs of basic blocks and conditions and is used to correctly connect outgoing edges to the following basic block which has not been created yet. Assume |exit| > 1 and next_blk will be the first basic block of the next statement. Then, for any (blk, cond) ∈ exit, there is a guarded transition from blk to next_blk with condition cond. The following describes how the syntax is processed in FIG. 2:
    • if (cond) {statement1} else {statement2} The condition cond joins the entry block because there is no branch between the previous statement and the condition. Since the control branches over cond, it is advantageous to initialize new basic blocks entry1 and entry2 to be the entry blocks for statement1 and statement2, respectively. The basic blocks of statement1 and statement2 are then created recursively. There are edges (entry_blkentry1) with the condition cond to be true, and (entry_blk → entry2) with the condition cond to be false. Finally, the exit blocks of the if statement are the union of the exit locks of statement1 and statement2.
    • while (cond) {body} Unlike the condition in an if statement that becomes part of entry_blk, the condition cond in a while statement starts a new block cond_blk because it is the destination of more than one basic blocks. Since the control may or may not transfer to body after cond, a new entry block body_blk is initialized and the basic blocks for body are created recursively. Let body_exit_blki (1 ≤ in) be the n exit blocks of body. There are unconditional edges (entry_blkcond_blk) and (body_exit_blki → cond_blk). A new basic block exit_blk is initialized to be the block that contains the statement immediately after the while statement. There are two conditional edges (cond_blkbody_blk) with the condition cond to be true, and (cond_blkexit_blk) with the condition cond to be false.
    • goto label If the statement labeled by a label has already been parsed, an unconditional edge (entry_blklabel_blk) is created, where label_blk is the basic block that contains the labeled statement. Otherwise, the basic block that contains the goto statement, i.e. entry_blk, is stored in a hash table G. The keys of the entries in the hash table are the label strings of the goto statements, and the contents are a list of basic blocks that contains the goto statements with the same destination. The hash table is used to create edges when a label statement is parsed.
    • label statement A new basic block label_blk is initialized for the labeled statement. It is preferable to create a new block so that the labeled statement may be the destination of goto statements, which makes the labeled statement destination of more than one basic block. Note that no basic blocks contain more than one labeled statement. If there are basic blocks in the hash table G that contain goto statement with the destination to this statement, an unconditional edge is created for each of the block to label_blk.
    • function calls After simplification of the program code, there are only two types of function calls: function_call(...) and var = function_call(...). FIG. 3 sets forth pseudo-code for generating basic blocks for non-recursive function calls. If there is parameter passing, statements are added that assign actual parameters to corresponding formal parameters to the basic block entry_blk. Note that only call-by-value is considered in FIG. 3. If the basic blocks of the called function have not been called, basic blocks can be created for it at line 3. A non-conditional edge from entry_blk to the first basic block in called_func is created. If the function call is of type var = function_call(...), a statement can be added by assigning the return expression in called_func to var. The statement is added to the block post_func_blk that is the exit block of the function call statement.
    • default By default a statement, such as an assignment, will not create any new basic blocks. In such a case, the statement is simply appended to the entry block.
  • FIG. 4 shows sample C code that illustrates the process of constructing the basic blocks. The code consists of three functions, and the control flow information is shown in the comments. The comments are in the form C → (Ni ) which show the indices of the current and next basic blocks, where C is the index of the basic block to which the current statement belongs. Different statements may belong to the same basic block, e.g., the first two assignments in function bar(). Note that each function call corresponds to two basic blocks although it is a single statement: one basic block holds parameter passing and the other basic block holds the returning position. Ni is a list of destinations of the current basic block. The if statement has two destination basic blocks. Which one is chosen depends on the condition logic. The return statement in each function may have multiple destinations which correspond to multiple calling positions to this function.
  • FIG. 5 shows another example of sample C code along with the computed control flow graph on the right. The example again shows how the basic blocks are computed for various types. Each basic block is identified in FIG. 5 by a unique number shown inside the hexagons adjacent to the basic blocks. The source node of the control flow graph is basic block 0, while the sink node is the highlighted basic block 8. The example in FIG. 5 pictorially shows how non-recursive function calls can be included in the control flow of the calling function. A preprocessing analysis determines the function "foo" is not called in any recursive manner. The two return points are recorded by an encoding that passes a unique return location as a special parameter using the variable "rtr."
  • The control logic can be expressed using 2 ┌logN┐ bits, where N is the number of basic blocks in the program. FIG. 6 depicts a truth table for the control logic. In FIG. 6, c 1, c 2, ... cn denote the current state variable, and c'1, c'2, ... c'n denote the next state variable where n = ┌logN┐. The j th table line represents a control flow graph edge υ 1 j υ 2 j υ n j υ 1 υ 2 υ n
    Figure imgb0001
    with condition kj where υ i j 0 1
    Figure imgb0002
    is an assignment to ci and υ i 0 1
    Figure imgb0003
    is an assignment to c'i . Based on the truth table, it is possible to build the next state logic for each next state variable as: f c i ʹ = j : υ i = 1 k j p : υ p j = 1 c p p : υ p j = 0 ¬ c p .
    Figure imgb0004
  • Data Logic. The data logic can be constructed as follows. All of the variables after simplification have finite domains. Assume that t bits can be used to represent a variable var with varj (1 ≤ jt) being the current state bits and var'j (1 ≤ jt) being the next state bits. Let var be assigned in blocks {b 1, b 2, ... bk } and not assigned in the remaining blocks {b k+1, ... bN }. The logic assigned to varj is Vji at block bi (1 ≤ ik). Also, let Ii be the index of the basic block bi . The data logic for varj is: var j ʹ = i = 1 k c 1 c 2 c n = I i V ji i = k + 1 N c 1 c 2 c n = I i var j .
    Figure imgb0005
  • FIG. 7 shows pseudo-code for constructing combinational circuits in order to obtain the variable assignment logic. FIG. 7 shows how to construct the circuit based on some common expressions, bitwise AND '&', sum '+', equality '==', constant and variable. The function "AND_gate(bit1, bit2)" creates an AND gate with two inputs bit1 and bit2. Similarly, "OR_gate()" and "XOR_gate()" create two-input OR and XOR gate, respectively. Lines 2-6 in FIG. 7 handle the expression of type expr1&expr2. It first recursively builds a circuit for the sub-expressions expr1 and expr2. Let vectors vec1 and vec2 be the outputs of the circuits for expr1 and expr2. The result vector has the same bitwidth as vec1 and vec2. Each result bit is the output of an AND gate with two inputs being the corresponding bits in vec1 and vec2. Lines 8-17 in FIG. 7 handle the expression of type expr1 + expr2. It creates an adder for each bit: var [ i]=vec[i]⊕vec[i]⊕carry_in. The logic for carry_in is (vec1[i] ∧ vec2[i]) ∨ (vec1[i] ∧ carry_in) v (vec2[i] ∧ carry_in) with initial value being zero. As to the equality in lines 19-24 in FIG. 7, the result vector has only one bit. If the statement is a constant, the result vector is a binary representation of the constant. Finally, if the statement is a variable, new signals are generated.
  • The modeling embodiment can be extended, with some special handling, to pointer variables. When a pointer variable is declared, additional variable can be introduced. The number of additional variables can be the same as the number of pointers. For example, the declaration {int ***p, ***q} will create four variables vp "', vp ", vp ', and vp for pointer p x each of which has its own data logic. The same number of variables can be created for q. All the newly generated variables are regular finite domain variables. However, implicitly vp denotes the referenced value of vp'. The same relationship holds for (vp ', vp ") and (vp ", vp "'). Note that an assignment to a pointer will change the face value as well as the referenced values, which result in additional assignments. If there is an assignment {*p = *q;} in the program, the following three assignments are generated: vp " = vq ", vp ' = vq ', vp = vq '. Similarly, {p = q;} results in four assignments that include vp "' = vq "'. A dereference in the C code also leads to additional variables and assignments. Let r be an integer variable. An assignment {*p = &r;} will first generate a new variable vr' that denotes the dereferenced value of vr , and then creates two assignments vp' = vr', vp = vr .
  • As discussed above, the code simplification process causes sequential assignments in each basic block to become parallel. Consider the following example assignments:
    • 0. int * * p, *a, *b, x;
    • 1. p = &a;
    • 2. a = &x;
    • 3. b = *p;
    • 4. *a = 5;
    The pointers can be handled as discussed above so that two new variables, denoted "&a" and "&x" are created. The additional assignments have to be inferred due to aliasing and newly introduced variables. The first assignment at line 1 becomes vp = 'va . Since p=&a implies *p=a and **p=*a, two new assignments vp' = va and vp " = va' are inferred. The assignment at line 2 gives rise not only to the assignment va' = vx due to a=&x → *a=x, but also to conditional assignments due to aliasing. Since p may be equal to &a, it is possible that *p and **p are assigned new values when a is assigned. This results in the conditional assignments *p= (p==&a) ? &x: *p and **p= (p==&a) ?x: **p. Note that b=*p does not need to be considered since &b does not appear in the code. All of the assignments are listed below:
    • 1.1. vp = 'va ;
    • 1.2. v'p = va ;
    • 1.3. v"p = v'a ;
    • 2.1. va = 'vx ;
    • 2.2. v'a = v x;
    • 2.3. v'p = (vp == 'va )?'vx : v'p ;
    • 2.4. v"p = (vp == 'va )?vx : v"p ;
    • 3.1. vb = v'p ;
    • 3.2. v'b = v"p ;
    • 4.1. v'a = 5;
    • 4.2. v"p = (v'p == va )?5 : v"p ;
    • 4.3. v'b = (vb == va )?5: v'b ;
    • 4.4. vx = ('vx == va )?5: 'vx ;
    The assignments labeled by m.1 with 1 ≤ m ≤ 4 are original assignments, while others are inferred:
  • Some of the conditions in the conditional assignments can be removed based on the previous assignments in the same basic block. For example, the condition (vp = = 'va ) at 2.3 and 2.4 can be removed because the assignment at 1.1 forces the condition to be true. Therefore, the assignments at 2.3 and 2.4 can be evaluated to vp' = 'vx and vp" = vx, respectively. The assignments at 2.1 and 2.3 together imply the condition v'p = = va at 4.2 to be true. Similarly, the conditions at 4.3 and 4.4 are true. Therefore, the conditional assignments can be simplified to the following form:
    • 2.3. v'p = 'vx ;
    • 2.4. υ p ʹʹ = υ x ;
      Figure imgb0006
    • 4.2. v"p = 5;
    • 4.3. v'b = 5;
    • 4.4. vx = 5;
  • Then, in order to convert the sequential assignments to parallel assignments, all possible read-after-write hazards are removed. By doing so, the read variables on the right hand side are replaced with the assigned value if the same variables were assigned previously in the same basic block. As a result, the assignments at 3.1 and 3.2 would be changed to vb = va and vb' = va', respectively. In addition, some assignments are redundant when considering a basic block as one atomic step. In particular, the assignments at later steps may overwrite previous assignments. The final assignments after removing prior assignments is shown below:
    • 1.1. vp = 'va ;
    • 2.1. va = 'vx ;
    • 2.3. v'p = 'vx ;
    • 3.1. vb = va ;
    • 4.1. v'a = 5;
    • 4.2. υ p ʹʹ = 5 ;
      Figure imgb0007
    • 4.3. υ b ʹ = 5 ;
      Figure imgb0008
    • 4.4. vx = 5;
    Note that the assignments now can be considered executed in parallel.
  • It should be noted that the present invention is not limited to the specific modeling techniques described above. For example, and without limitation, one can use an alternative translation such as the more conventional one of modeling the heap as a set of locations.
  • ABSTRACTION. Abstraction is probably the most important technique for reducing the state explosion problem in model checking. Predicate abstraction has emerged to be a powerful and popular technique for extracting finite-state model from complex, potentially infinite state systems. As depicted in FIG. 1, the abstraction step 130 takes advantage of the technique of predicate abstraction 132. This approach depends on the ability to identify interesting predicates to be used for abstraction and on the ability to compute abstract transitions correctly. In contrast to early work on predicate abstraction for software which uses extensive and inherently expensive calls to various theorem provers to compute the transition relations in the abstract system, it is advantageous to follow a SAT-based approach to compute the transition relation, as disclosed herein. Additionally, and as further discussed below, it is advantageous to allow the computation of approximate abstract models and to constrain the implementation of the enumeration of the various transition relations to reuse certain common computations, thereby allowing faster computation.
  • Consider a set of n Boolean predicates P = {p 1, ... , pn } ⊂Σ. The truth values to these Boolean predicates are to be updated after the election of each block given the values to the Boolean predicates when entering the considered block. Define a function Preds : 2 x → 2 P that maps a set M of variables to the predicates that range over these variables and their references and dereferences Preds(M)={pP|Vars(p)∩M ≠ ∅}. The set of required variables for a predicate p given a parallel assignment v1 , ... , vn ← e 1, ... en is R p = x X | υ i Vars p x Vars e i X .
    Figure imgb0009

    Although the variables in R(p) influence p directly, it is necessary to include more predicates and variables into the analysis to reach the full precision provided by the predicate set P as R p P = R p χ R q | v R p P q Pr eds v ,
    Figure imgb0010

    which can also be computed iteratively. This can be generalized for a set of predicates P ⊆ P to R(P,P) = U p P R(p,P) ⊆ X. The sets of unused variables for a predicate p and a set of predicates P can then be defined as
    U(p,P)=X\(Vars(p)∪R(p,P)) and U(P,P) = X\(Vars(P)∪R(P,P)). For a parallel assignment, the set of predicates to be updated can be defined as Pv = Preds(V), the set of predicates required as PR = Preds (R(P,P)) and the set of unused predicates as P =P\(Pv PR ).
  • For each predicate p ∈ P a new Boolean variable b can be added to the abstraction of the program. For the set P = {p 1, ... , pn }, consider an abstraction based on the set B ={b 1 ,...,bn }. For notational convenience, consider the evaluation of the Boolean representation often to be a vector b = (b 1,...bn ) T ∈ Bn rather than a set. The following discussion discloses two ways of implementing the computation of a transition relation describing the current-state to next-state relationship for these Boolean variables bi . In this context, the current-state of a Boolean variable denotes the evaluation of the Boolean variable when entering a new basic block, while the next-state denotes the evaluation of the same Boolean variable after executing all statements in the basic block, that is, just before exiting the basic block. It should be noted that the initial state of the abstraction is completely random, that is any truth combination to B is valid.
  • More formally, define the set T = {0,1,⊥,?} as a superset of B for abstraction purposes. The symbol ⊥ corresponds to the same symbol in the concrete state-space, namely a predicate evaluates to ⊥ when it is out-of-scope in a given basic block. The symbol "?" is used to denote the fact that although the predicate is defined in a given basic block, we are not interested in its evaluation to true(1) or false(0). This notation can be used for the description of approximate abstractions.
  • The set of abstract states QP for a vector of predicates P ∈ Σ n of length n is thus QP = L x T n . Similar to the concrete state-space, define a location-specific set Tl P which only contains consistent vectors b with respect to the scope of predicates for a given location l. The set of initial abstract states then is Q 0 P = l 0 b | b T l 0 P .
    Figure imgb0011
  • The concretization γ(b) ofa Boolean predicate vector b=(b 1,..,bn ) T Bn is the set of true assignments to the expression γ b = x X | b 1 p 1 x b n p n x
    Figure imgb0012

    Assuming one knows the range of all variables in Pv , a bit-blasted expression can be generated that can be used to enumerate all such assignments using the algorithm described in K.L. McMillan, "Applying SAT Methods in Unbounded Symbolic Model Checking," in 14th Int'l Conference on Computer Aided Verification, Vol. 2404 of Lecture Notes in Computer Science, pp. 250-64 (2002). The range analysis framework can be used to find an appropriate bitwidth for each variable and statement in the program. Note also that it is easy to extend these definitions to the set T instead of B, as well as to extend it to the abstract states QP . If one considers the concrete transition relation →⊆ Q x Q, one can then define the abstract transition relation → P ⊆ QP x QP given a vector of predicates P as: l 1 b 1 P l 2 b 2 : b 1 T l 1 P b 2 T l 2 P x 1 γ b 1 , x 2 γ b 2 . l 1 x 1 l 2 x 2 .
    Figure imgb0013
  • If σ ∈ Σ is an expression, YX is a set of k variables, and σ 1,...,σk are k expressions, then σ[Y
    Figure imgb0014
    σ1,..., σ k ] denotes the expression obtained by point-wise substitution of the expressions σ i for the variables Y in σ.
  • For a block with assignment set V, a set of updated predicates PV , and the set of required predicates PR , the set B can be partitioned accordingly into sets BV and BR , corresponding to PV and PR respectively. A Boolean expression can be obtained representing a transition relation T(b,b'j,X) for the next state of a Boolean variable b j ʹ
    Figure imgb0015
    for a Boolean variable bj Bv depending on the current state Boolean variables in B R 3 , as T b b j ʹ χ : = b i B R b i p i b j ʹ p j V e 1 , , e n .
    Figure imgb0016

    (It should be noted that the set BR was computed on the basis of all predicates, and can be relaxed if a single predicate at a time is being considered. That is, if a single predicate p is considered, the set PR is Preds(R(p))). Similarly, a Boolean expression can be obtained which represents a transition relation T(b, b',X) for the next state of all Boolean variables in BV depending on the current state Boolean variables in BR as T b χ : = b i B R b i p i b i B V b i ʹ p i V e 1 , , e n b i B V b i ʹ = b i .
    Figure imgb0017
  • The above transition relations can be restricted to range only over Boolean variables by defining T(b,b'):= ∃xX.T(b, b',x), and T(b,b'j ):= ∃xX.T(b,b'j,x). For notational convenience, we also denote the set {y'|yM} for any set M using the notation M'. Hence, we use B J ʹ ,
    Figure imgb0018
    to denote the set b i ʹ | b i B V .
    Figure imgb0019
  • For each basic block, one transition relation T(b,b', X) is thus generated. Every satisfying assignment A of the transition relation represents a transition in the concrete system - the considered C-block - and its abstraction given the current set of Boolean predicates. In order to compute T(b,b'), one can project such a satisfying assignment onto the Boolean variables b and b', and thus obtain one possible transition in the abstracted system by defining an abstract satisfying assignment AB as A B = A | B R B V ʹ .
    Figure imgb0020
    Since one is only interested in finding all possible transitions in the abstract system, an efficient implementation of the enumeration algorithm can be used. See McMillan reference above. The enumeration of abstract transitions proceeds by iterative additions of so-called blocking clauses that disallow a previous solution to reappear. After adding the blocking clause ¬AB to the Boolean expression , T(b,b',X), the SAT-solver can then be asked to find another satisfying assignment of the enriched problem formulation, if such an assignment still exists. The enumeration of the transition relation using a SAT-solver is a more efficient way of computing the transition relation compared to using expensive and exponentially many calls to a theorem prover.
  • The implementation of the enumeration of the various transition relations can be further improved by constraining the implementation to reuse certain common computations, thereby allowing faster overall computation. Since many transition relations need to be computed, where the set of considered Boolean variables often remains only partially the same, an intelligent scheduling of the enumeration of these transition relations and a proper memory management of derived implications, can potentially reduce the computation time of the overall abstraction procedure as viewed for the entire program significantly.
  • It should be noted that in many cases the set of n predicates does not imply that there are 2 n many consistent abstract interpretations of these predicates. In fact, as it turns out, often there are many redundant or parallel predicates where many combinations of these evaluations do not correspond to any concrete state. A simple preprocessing step analyzing whether predicates are parallel to each other can save considerable time at run-time. Consider for example a case that involved 35 relevant predicates which could be divided into four sets of parallel predicates of size eight, eight, nine and nine and a single non-parallel predicate. Parallel predicates in the present context includes predicates such as 2 x - y - 4 z 5 = 2 ,
    Figure imgb0021
    2 x - y > 5 + 4 z 5 ,
    Figure imgb0022
    and 2x-0.8z < y. In such a set of nine parallel predicates, for example, there are at most ten consistent evaluations whereas a full search would loop over 29 many combinations. In the previously mentioned case, the 35 predicates thus can at most represent 2.92·102 < 214 many abstract consistent states. This reduces the analysis at this point of the computation by a factor of more than 221 > 2 · 106. The total saved computation time is a multiple of this since this saving can be re-used in multiple transition relation computations.
  • In addition to the above-described analysis of parallel predicates, there are often other non-consistent evaluations of the predicates in the concrete state-space. For example, for a set of separation predicates which are predicates of the form xi - xj c with ~∈ {>,≥} and c a constant, one can decide the valid combination of the set of these predicates. Such reductions of the set of feasible valid combinations can be helpful for later processing steps if the set of feasible combinations can be expressed concisely. A full enumeration of the feasible combinations may also be possible; however, the resulting set of feasible combinations may not be concise enough. It is also helpful to discover certain relationships and implications during an enumeration and remember these for later computation steps.
  • For the enumeration of the transition relation from current-state to next-state Boolean variables, the effect of reducing the size of the feasible Boolean predicate truth combinations shows up both in the current-state representation as well as the next-state representation of these variables. In addition, an analysis of various basic block computations and an intelligent scheduling of the enumeration of various transition relations can significantly save time during the computation of the abstraction. Consider, for example, the following code fragment which is often found in some similar form in many software applications:
                if ( condition )
                   x++; /* then-part */
                else
                   x += 2 ; /* else-part */
For illustration purposes, consider here two predicates b 1 representing x > 2 and b 2 representing x > 3. Then, the expression x>1 represents the pre-condition for b 1 ʹ .
Figure imgb0023
to be true in the then-part of the code fragment, written as b 1 ʹ then ,
Figure imgb0024
while it also represents b 2 ʹ else .
Figure imgb0025
One can thus save one whole computation of transition relations by combining the two enumerations into one. Thus, one can enumerate the following expression b 1 x > 2 b 2 x > 3 b 1 ʹ then x > 1 b 2 ʹ then x > 2 b 1 ʹ else x > 0 b 2 ʹ else = b 1 ʹ then .
Figure imgb0026
(It should be noted that this is a simple case where further preprocessing could be performed; these are omitted in the presentation for clarity purposes, and it should also be noted that the size of the reduction increases by incorporating more predicates). Even if the computation cannot be combined in the way as presented above, it is often the case that the set of considered Boolean predicates and instructions is partially the same in various transition relations representing different basic blocks. An analysis of these cases and a scheduling that allows the enumeration of common parts first, can then be used to minimize the amount of total computations needed for all transition relations.
  • The overall run-time can be further reduced by allowing the , computation of approximate abstract models to reduce the abstraction time. For example, while it may not be feasible to enumerate the set of possible solutions for the full transition relation between current-state and next-state Boolean predicate variables, it may be possible to reduce the run-time by enumerating multiple transition relations where only a subset of or even individual next-state Boolean predicate variables are considered at a time. For example, if not all these transition relations can be enumerated, it may be possible to leave some transition relations unspecified thus allowing a nondeterministic choice to the following model checking step. On the other hand, an approximation can also be computed based on the overall transition relation by excluding some abstracted satisfying assignments from further consideration. Such decisions are usually made based on a predetermined maximal length of clauses to be considered. To compute an approximate abstraction, it has been noted that it is only necessary to check the following expressions for unsatisfiability. The transition in the abstract state-space between the abstract states (l 1,b 1) and (l2,b 2) is included in the approximate transition relation, that is (l 1,b 1) → (l2,b 2), if and only if the expression x 1 γ b 1 , x 2 X l 2 \ γ b 2 l 1 x 1 l 2 x 2
    Figure imgb0027
    is unsatisfiable. By limiting the number of significant predicates to a small constant, that is by iterating only over abstract states with a pre-determined number of 0's or 1's in their predicate vector representation and ? and ⊥ appropriately elsewhere, an over-approximation of the transition relation can be simply constructed. One can also distinguish between the number of significant bits in the current-state (l 1,b 1) and the next-state (l2,b 2) during this iteration. Since approximations of the transition relation → P are allowed, one can denote the approximate transition relation as ↪ P and perform the reachability analysis in general using the transition relation ↪ P .
  • COUNTER-EXAMPLE ANALYSIS & REFINEMENT. Allowing an over-approximation of the considered abstraction model thus reduces the run-time of the computation of the abstraction, but also increases the risk that spurious counter-examples will appear during the model checking phase. Accordingly, as set forth in FIG. 1, the system performs an analysis searching for such spurious counter-examples at 160 and further refinement at 170.
  • The concept of spurious counter-examples can be generalized to testing for the feasibility of sub-paths or "fragments." Formally, define an abstract path of length k in the abstract state-space Q P for a set of predicates P given a set of unsafe locations Bad ⊆ L as a sequence of k abstract states (l 0, b 0),...(l k-1,b k-1) such that l 0 b 0 Q 0 P
    Figure imgb0028
    is an initial abstract state and ∀0 ≤ ik-1: (l i,b i) → P (l i+1,b i+1). An abstract counter-example of length k then is a path that ends in an unsafe location, that is l k-1 ∈ Bad. However, since approximate transition relations are allowed, define approximate abstract paths and approximate abstract counter-examples analogously using the relation ↪ P instead of → P . For the counter-example analysis, define an expression that corresponds to a fragment of the counter-example of length k. Define a timed version of the transition relation → in the concrete state-space or a time-step or unrolling i with 0 ≤ i < k-1 over the timed or unrolled variables as Ti . Since the sequence of basic blocks in an approximate abstract path (l 0,b 0),...,(l k-1,b k-1) is known, one can for efficiency purposes additionally limit the various timed relations Ti in the implementation to the appropriate transition in the control flow graph to the basic block transition from li to l i+1. Fragments can then be defined for 0 ≤ i < j < k as: ϕ i j : = γ b i T i γ b i + 1 T j - 1 γ b j .
    Figure imgb0029
    If the expression ϕ(i,j) is unsatisfiable for any pair 0 ≤ i < j < k, it has been discovered that the counterexample is indeed spurious.
  • It should be noted that prior art analysis and refinement approaches consider spurious transitions, which consider fragments of the form j = i+1. Also, traditional prefix counter-example analysis approaches consider only fragments of the form i = 0 with a minor addition. Namely, when including the first abstract state, it is also necessary to verify that a possible path through the counter-example starts within the set of initial states. However, in the present case, since all well-defined states in X l 0 in basic block l 0 are defined to be initial, this check can be omitted here. For the full counter-example analysis, thus, the system simply considers the expression φ := ϕ(0, k - 1).
  • The additional work invested to discover better reasons for spurious counter-examples thus yielding stronger predicates, can reduce the number of iterations needed to prove or disprove reachability in the overall counter-example-guided abstraction refinement approach significantly. This kind of analysis of fragments will increasingly be more important the longer the counter-examples become. While the reason for a spurious counter-example may be a local problem in a sequence of relatively few abstract states, the prefix analysis as advocated so far in all other counter-example-guided refinement approaches may distort the real reason and discover a sub-quality set of new predicates. A similar counter-example with a very similar spurious fragment can still re-appear in the following iterations if it is not accounted for during prior analysis and refinement steps.
  • Where a SAT solver is utilized as the model checker, the SAT solver can generate a subformula that is unsatisfiable, otherwise known as an unsatisfiability core. The refinement of spurious counterexamples can be further focused by using the unsatisfiability cores computed by the SAT solver.
  • CUSTOMIZED DECISION HEURISTICS. The Boolean representations generated by the system contain many common features that are based on the particular translation presented here. Although the program counter described above tracks progress in the control flow graph, there is additional information in the original software that could improve the efficiency of the model checking. In the context of bounded model checking, there are various heuristics that can improve the performance.
  • Scoring of PC Variables. A simple decision heuristic that increases the likelihood that a SAT solver makes decisions first on variables that correspond to the control flow rather than the data flow, takes advantage of the fact that each new unrolling does not allow the whole code to be reached based on a static analysis of the control flow graph. This heuristic can be implemented by increasing the score for the bits of the pc variables, which in turn makes the back-end SAT solver choose these variables as decision variables first. This heuristic forces the model checker to focus first on a static reachability computation of the control flow graph and is, thus, able to eliminate many traces quickly. In addition to scoring pc variables higher than other variables in the system, it can also be advantageous to control how to vary the scoring of variables over various time frames. For example, increasing the relevance of pc variables more in later time-frames than in previous ones takes advantage of the SAT-solver decisions inherent in the above-mentioned DIVER tool.
  • One-Hot Encoding. Another heuristic that is useful is a one-hot encoding of the pc variables which allows the SAT solver to make decisions on the full pc. In addition to the binary encoded pc variable already present in the circuit, a new selection bit can be added for each basic block. The selection bit can be set iff the basic block is active, i.e., when a certain combination of pc variables bits is valid. This provides a mechanism for word-level decisions since a certain basic block selection bit automatically invalidates all other basic block selection bits through the pc variables. By increasing the score to set a basic block selection bit compared to other variables in the system, one is able to influence the SAT solver to make quick decisions on the location first. An obvious disadvantage to this heuristic is that one needs to include one selection bit to the Boolean model per basic block in the software program.
  • In addition, one is able to increase the score intelligently for these basic block selection bits by considering the pre-computed static reachability information from the control flow graph. One only needs to increase the score for those basic block selection bits at depth k, if the corresponding basic block can actually be reached statically in the control flow graph at depth k. This requires an additional BFS of reachable basic blocks at various depths on the control flow graph.
  • Consider the control flow graph illustrated by FIG. 5. Each basic block in the control flow graph can be given a unique number which would be used to describe the one-hot encoding. Let bi represent the selection bit for basic block i and let ci , 0 ≤ i ≤ 3 represent the four needed program counter variable bits. Constraints can be added for each basic block, asserting the equality of the basic selection variable with the binary-encoded program counter label. For example, b0 = 3 2 1 0 and b 6 = 3 2 1 0. Now, a decision by the SAT-solver to assign b 0 to 1 corresponds to a word-level decision on the program counter, which immediately results in implying bi = 0, i > 0, including b 6 = 0 in the example.
  • Furthermore, similar to the previously described advantage to score variables in later time-frames higher than in prior time-frames, it is also possible to use the same strategy for the scoring of the selection bits described in this heuristic.
  • Explicit Modeling of CFG Transitions. It is also advantageous to aid the analysis of the back-end SAT-solver by constraining its search space to eliminate impossible predecessor basic block combinations in the control flow graph. These constraints capture additional high-level information, which helps to prune the search space of the SAT-solver. At each depth, the choice of the SAT-solver to consider a particular basic block enables a limited number of possible predecessor blocks and eliminates immediately all other basic blocks from consideration. By increasing the likelihood that the SAT-solver decides first on the pc, one can take advantage of the fact that each new unrolling does not allow the whole code to be reachable at each depth. It is preferable to add these constraints based on incoming transitions into a basic block since the Boolean model of the software already encodes the outgoing transitions in terms of the pc variables.
  • For example, assuming that ci' with 0 ≤ i ≤ 3 denotes the next state pc variables bits, the following constraint is added for basic block 7 of FIG. 5: c 3 ʹ c 2 ʹ c 1 ʹ c 0 ʹ c 3 c 2 c 1 c 0 c 3 c 2 c 1 c 0 .
    Figure imgb0030
    Similarly, for basic block 3, add the following constraint: c 3 ʹ c 2 ʹ c 1 ʹ c 0 ʹ c 3 c 2 c 1 c 0 g ,
    Figure imgb0031
    where g stands for the representation of "x>4". Such constraints can also be added in terms of the one-hot encoded selection bits of the basic blocks if both these heuristics are being utilized. The constraint for basic block 7 then simply becomes b 7 ʹ b 3 b 4 .
    Figure imgb0032
    With the addition of this constraint, if the SAT-solver assigns b 7' to 1, i.e., the current block is 7, then the predecessor block is required to be one of the blocks 3 or 4.
  • This heuristic can be customized by choosing a subset of basic blocks for which to apply the heuristic. This customization allows the user to fine-tune the amount of additional constraints generated, since too many additional constraints may burden the SAT-solver rather than improve efficiency. For example, and without limitation, a user can be allowed to specify the following choices:
    • Include additional constraints for all basic blocks in the control flow graph.
    • Include additional constraints only for those basic blocks that have multiple incoming transitions. This option requires the SAT-solver to pick one incoming edge when there are several choices. This allows the SAT-solver to quickly focus on a single feasible path at a time.
    • Include additional constraints only for those basic blocks that have a single incoming transition. This option helps the SAT-solver to quickly propagate a path backwards when there are no multiple incoming edges. This process alleviates unnecessary decisions on pc variables immediately in such basic blocks.
    In addition, another optimization is to limit the additional constraints to basic blocks at depths that are actually reachable at that depth. This optimization, similar to the optimization described above in the one-hot encoding heuristic, requires an additional BFS of reachable basic blocks.
  • While exemplary drawings and specific embodiments of the present invention have been described and illustrated, it is to be understood that that the scope of the present invention is not to be limited to the particular embodiments discussed. Thus, the embodiments shall be regarded as illustrative rather than restrictive, and it should be understood that variations may be made in those embodiments by workers skilled in the arts without departing from the scope of the present invention as set forth in the claims that follow. As but one of many variations, it should be understood that programming languages other than C can be readily utilized in the context of the present invention.
  • Claims (23)

    1. A method of verifying a software program (101) characterized by comprising:
      modeling the software program, which can have bounded recursion, as a Boolean representation comprising a plurality of basic blocks, each basic block representing a sequence of one or more instructions in the software program as a set of parallel assignments and a set of transitions to other basic blocks; and
      applying a SAT-based model checker (150) to the Boolean representation of the software program.
    2. The method of claim 1 wherein the model checker is a back-end SAT solver that uses bounded model checking.
    3. The method of claim 1 wherein the model checker proceeds by iterative unrolling of the basic blocks, each unrolling being a block-wise execution of the software program.
    4. The method of claim 3 wherein each basic block has a label and wherein a program counter variable is used to track progress of allowed executions of the software program during processing by the model checker.
    5. The method of claim 4 wherein the program counter variable is given an increased score when the model checker is applied, so as to cause the model checker to focus first on control flow in the software program.
    6. The method of claim 4 wherein each basic block is assigned a selection bit which is set to a value based on the program counter variables, so as to allow the model checker to focus on parts of the control flow in the software program identified by the selection bits.
    7. The method of claim 4 wherein constraints are added when the model checker is applied, in which the constraints prune the model checker's search space of impossible predecessor-successor basic block combinations.
    8. The method of claim 7 wherein the constraints are only applied to a subset of the basic blocks in the Boolean representation.
    9. The method of claim 1 wherein the software program is further modeled using a bounded stack to handle bounded recursion in the software program.
    10. The method of claim 1 wherein the software program is partially abstracted during the modeling such that the Boolean representation contains both abstracted variables and variables left in their concrete representations.
    11. The method of claim 1 wherein transition relations in the Boolean representation of the software program are enumerated using SAT-based enumeration.
    12. The method of claim 11 wherein transition relations in the Boolean representation of the software program are enumerated and represented by: T b b j ʹ χ : = b i B R b i p i b j ʹ p j V e 1 , , e n .
      Figure imgb0033
    13. The method of claim 11 wherein transition relations in the Boolean representation of the software program are enumerated and represented by: T b χ : = b i B R b i p i b i B V b i ʹ p i V e 1 , , e n b i B V b i ʹ = b i .
      Figure imgb0034
    14. The method of claim 1 wherein common computations in transition relations in the Boolean representation of the software program are reused to speed up computation.
    15. The method of claim 1 wherein range analysis (113) is performed prior to modeling the software program in order to limit the size of variables in the Boolean representation of the software program.
    16. The method of claim 1 wherein program slicing (112) is performed to decompose the software program into related elements prior to modeling the software program.
    17. The method of claim 1 wherein approximate abstraction modeling is utilized and wherein, if the model checker generates a counter-example, the counter-example is checked for whether it is spurious.
    18. The method of claim 17 wherein the counter-example checking further comprises testing feasibility of sub-paths.
    19. The method of claim 17 wherein, if the counter-example is spurious, refinement is conducted using an unsatisfiability core computed by the model checker.
    20. A software verification system comprising:
      an input module which receives a software program to be analyzed, where the software program can have bounded recursion;
      whereby the software verification system is characterized by further comprising:
      a modeling module which translates the software program into a Boolean representation, the Boolean representation comprising a plurality of basic blocks, each basic block representing a sequence of instructions in the software program as a set of parallel assignments and a set of transitions to other basic blocks; and
      a SAT-based model checker (150) which receives and processes the Boolean representation of the software program.
    21. The system of claim 20 wherein the model checker is a back-end SAT solver that uses bounded model checking.
    22. The system of claim 20 wherein the model checker processes the Boolean representation of the software program by iterative unrolling of the basic blocks, each unrolling being a block-wise execution of the software program.
    23. The system of claim 22 wherein each basic block has a label and wherein a program counter variable is used to track progress of allowed executions of the software program during processing by the model checker.
    EP20050705999 2004-01-22 2005-01-21 System and method for modeling, abstraction, and analysis of software Expired - Fee Related EP1706833B1 (en)

    Priority Applications (3)

    Application Number Priority Date Filing Date Title
    US53852404P true 2004-01-22 2004-01-22
    US11/040,409 US7346486B2 (en) 2004-01-22 2005-01-21 System and method for modeling, abstraction, and analysis of software
    PCT/US2005/001963 WO2005072257A2 (en) 2004-01-22 2005-01-21 System and method for modeling, abstraction, and analysis of software

    Publications (3)

    Publication Number Publication Date
    EP1706833A2 EP1706833A2 (en) 2006-10-04
    EP1706833A4 EP1706833A4 (en) 2010-03-17
    EP1706833B1 true EP1706833B1 (en) 2011-09-28

    Family

    ID=34798169

    Family Applications (1)

    Application Number Title Priority Date Filing Date
    EP20050705999 Expired - Fee Related EP1706833B1 (en) 2004-01-22 2005-01-21 System and method for modeling, abstraction, and analysis of software

    Country Status (5)

    Country Link
    US (1) US7346486B2 (en)
    EP (1) EP1706833B1 (en)
    JP (1) JP2007528059A (en)
    AT (1) AT526628T (en)
    WO (1) WO2005072257A2 (en)

    Families Citing this family (122)

    * Cited by examiner, † Cited by third party
    Publication number Priority date Publication date Assignee Title
    US7058925B2 (en) * 2002-04-30 2006-06-06 Microsoft Corporation System and method for generating a predicate abstraction of a program
    US9106694B2 (en) 2004-04-01 2015-08-11 Fireeye, Inc. Electronic message analysis for malware detection
    US8171553B2 (en) 2004-04-01 2012-05-01 Fireeye, Inc. Heuristic based capture with replay to virtual machine
    US8898788B1 (en) 2004-04-01 2014-11-25 Fireeye, Inc. Systems and methods for malware attack prevention
    US8881282B1 (en) 2004-04-01 2014-11-04 Fireeye, Inc. Systems and methods for malware attack detection and identification
    US8566946B1 (en) 2006-04-20 2013-10-22 Fireeye, Inc. Malware containment on connection
    US8528086B1 (en) 2004-04-01 2013-09-03 Fireeye, Inc. System and method of detecting computer worms
    US8584239B2 (en) 2004-04-01 2013-11-12 Fireeye, Inc. Virtual machine with dynamic data flow analysis
    US7743350B2 (en) * 2004-05-21 2010-06-22 Fujitsu Limited Verifying one or more properties of a design using SAT-based BMC
    US8549638B2 (en) 2004-06-14 2013-10-01 Fireeye, Inc. System and method of containing computer worms
    DE102004033339A1 (en) * 2004-07-09 2006-02-02 Infineon Technologies Ag Method and apparatus for locating circuit deviations
    US7322016B2 (en) * 2005-01-11 2008-01-22 International Business Machines Corporation Impact checking technique
    US20060247907A1 (en) * 2005-04-29 2006-11-02 Microsoft Corporation Deciding assertions in programs with references
    US7930659B2 (en) * 2005-06-03 2011-04-19 Nec Laboratories America, Inc. Software verification
    US7640536B1 (en) * 2005-09-27 2009-12-29 Rockwell Collins, Inc. Variable graph minimization for improved model-checking performance
    US7835898B2 (en) * 2005-11-22 2010-11-16 International Business Machines Corporation Satisfiability (SAT) based bounded model checkers
    US8799882B2 (en) * 2005-12-07 2014-08-05 Microsoft Corporation Compiler support for optimizing decomposed software transactional memory operations
    US7590806B2 (en) 2005-12-07 2009-09-15 Microsoft Corporation Filtering of transactional memory operations using associative tables
    US7926025B2 (en) * 2005-12-30 2011-04-12 Microsoft Corporation Symbolic program model compositions
    US8683441B2 (en) * 2006-01-11 2014-03-25 International Business Machines Corporation Software equivalence checking
    US7536602B2 (en) * 2006-02-17 2009-05-19 Alcatel-Lucent Usa Inc. Method and apparatus for evaluating paths in a state machine
    US7926039B2 (en) * 2006-03-28 2011-04-12 Nec Laboratories America, Inc. Reachability analysis for program verification
    US7509534B2 (en) * 2006-06-27 2009-03-24 Microsoft Corporation Counterexample driven refinement for abstract interpretation
    US8171438B2 (en) * 2006-08-25 2012-05-01 International Business Machines Corporation Verification of a program partitioned according to the control flow information of the program
    KR20090071596A (en) * 2006-09-20 2009-07-01 내셔널 아이씨티 오스트레일리아 리미티드 Generating a transition system for use with model checking
    US7934201B2 (en) * 2006-10-17 2011-04-26 Artoftest, Inc. System, method, and computer readable medium for universal software testing
    US7921411B2 (en) * 2006-10-20 2011-04-05 International Business Machines Corporation Model checking of non-terminating software programs
    JP4884177B2 (en) * 2006-11-17 2012-02-29 ヤマハ発動機株式会社 Marine steering system and a ship
    FR2911971B1 (en) * 2007-01-26 2009-04-24 Commissariat Energie Atomique Method and properties of verification system of a computer program.
    US7685471B2 (en) * 2007-02-01 2010-03-23 Fujitsu Limited System and method for detecting software defects
    US9405819B2 (en) * 2007-02-07 2016-08-02 Fujitsu Limited Efficient indexing using compact decision diagrams
    US20090007038A1 (en) * 2007-04-05 2009-01-01 Nec Laboratories America, Inc. Hybrid counterexample guided abstraction refinement
    JP4924188B2 (en) * 2007-04-27 2012-04-25 トヨタ自動車株式会社 Cross-verification device
    CN102513024B (en) * 2007-07-03 2015-02-11 佐治亚-太平洋化工品有限公司 Chemical modification of maleated fatty acids
    US8069434B2 (en) * 2007-10-29 2011-11-29 Sap Ag Integrated model checking and issue resolution framework
    US7949511B2 (en) * 2007-11-12 2011-05-24 Nec Laboratories America, Inc. System and method for tunneling and slicing based BMC decomposition
    US7587537B1 (en) 2007-11-30 2009-09-08 Altera Corporation Serializer-deserializer circuits formed from input-output circuit registers
    US20090193417A1 (en) * 2008-01-24 2009-07-30 Nec Laboratories America, Inc. Tractable dataflow analysis for concurrent programs via bounded languages
    US7441216B1 (en) * 2008-03-31 2008-10-21 International Business Machines Corporation Applying CNF simplification techniques for SAT-based abstraction refinement
    US8549486B2 (en) * 2008-04-21 2013-10-01 Microsoft Corporation Active property checking
    US20090282289A1 (en) * 2008-05-06 2009-11-12 Microsoft Corporation Generation and evaluation of test cases for software validation and proofs
    US8402439B2 (en) * 2008-06-27 2013-03-19 Microsoft Corporation Program analysis as constraint solving
    JP5093508B2 (en) * 2008-10-15 2012-12-12 日本電気株式会社 Loop optimization system, the loop optimization method, and loop optimization program
    US8850571B2 (en) 2008-11-03 2014-09-30 Fireeye, Inc. Systems and methods for detecting malicious network content
    US8997219B2 (en) 2008-11-03 2015-03-31 Fireeye, Inc. Systems and methods for detecting malicious PDF network content
    US20100169618A1 (en) * 2008-12-30 2010-07-01 Microsoft Corporation Identifying concurrency control from a sequential proof
    US8875111B2 (en) * 2009-04-23 2014-10-28 Microsoft Corporation Intermediate language representation and modification
    US8539451B2 (en) * 2009-05-12 2013-09-17 Nec Laboratories America, Inc. Systems and methods for model checking the precision of programs employing floating-point operations
    US8402444B2 (en) * 2009-10-09 2013-03-19 Microsoft Corporation Program analysis through predicate abstraction and refinement
    US8280899B2 (en) * 2009-10-14 2012-10-02 Microsoft Corporation Abstracting events for data mining
    US8156459B1 (en) * 2009-11-10 2012-04-10 Xilinx, Inc. Detecting differences between high level block diagram models
    US8775150B1 (en) * 2009-12-17 2014-07-08 Cadence Design Systems, Inc. Method and system for providing an implicit unknown value to user enum data constructs in an HDL system to model power shutoff in simulation
    JP5287693B2 (en) * 2009-12-18 2013-09-11 トヨタ自動車株式会社 Program inspection equipment
    US8595707B2 (en) * 2009-12-30 2013-11-26 Microsoft Corporation Processing predicates including pointer information
    US8495588B2 (en) * 2010-04-16 2013-07-23 International Business Machines Corporation Abstraction-guided synthesis
    US8490057B2 (en) 2010-09-30 2013-07-16 International Business Machines Corporation Confidence-based static analysis
    US20120192013A1 (en) 2010-11-22 2012-07-26 Certon Software Inc. Verification of Signal Processing Using Intelligent Points
    US8832659B2 (en) * 2010-12-06 2014-09-09 University Of Washington Through Its Center For Commercialization Systems and methods for finding concurrency errors
    US20120198399A1 (en) * 2011-01-31 2012-08-02 Sean Arash Safarpour System, method and computer program for determining fixed value, fixed time, and stimulus hardware diagnosis
    US8650546B2 (en) * 2011-06-30 2014-02-11 International Business Machines Corporation Static analysis based on observed string values during execution of a computer-based software application
    US8893102B2 (en) * 2011-07-27 2014-11-18 Oracle International Corporation Method and system for performing backward-driven path-sensitive dataflow analysis
    US20130247000A1 (en) * 2012-03-13 2013-09-19 International Business Machine Corporation Dynamic synthesis of program synchronization
    US9292693B2 (en) * 2012-10-09 2016-03-22 International Business Machines Corporation Remediation of security vulnerabilities in computer software
    US8973131B2 (en) * 2012-11-02 2015-03-03 International Business Machines Corporation Refinement-based security analysis
    US20140195208A1 (en) * 2013-01-09 2014-07-10 GM Global Technology Operations LLC Efficient partition refinement based reachability checking for simulinks/stateflow models
    US9009823B1 (en) 2013-02-23 2015-04-14 Fireeye, Inc. Framework for efficient security coverage of mobile software applications installed on mobile devices
    US9176843B1 (en) 2013-02-23 2015-11-03 Fireeye, Inc. Framework for efficient security coverage of mobile software applications
    US9159035B1 (en) 2013-02-23 2015-10-13 Fireeye, Inc. Framework for computer application analysis of sensitive information tracking
    US8990944B1 (en) 2013-02-23 2015-03-24 Fireeye, Inc. Systems and methods for automatically detecting backdoors
    US9009822B1 (en) 2013-02-23 2015-04-14 Fireeye, Inc. Framework for multi-phase analysis of mobile applications
    US9367681B1 (en) * 2013-02-23 2016-06-14 Fireeye, Inc. Framework for efficient security coverage of mobile software applications using symbolic execution to reach regions of interest within an application
    US9355247B1 (en) 2013-03-13 2016-05-31 Fireeye, Inc. File extraction from memory dump for malicious content analysis
    US9626509B1 (en) 2013-03-13 2017-04-18 Fireeye, Inc. Malicious content analysis with multi-version application support within single operating environment
    US9430646B1 (en) 2013-03-14 2016-08-30 Fireeye, Inc. Distributed systems and methods for automatically detecting unknown bots and botnets
    US9311479B1 (en) 2013-03-14 2016-04-12 Fireeye, Inc. Correlation and consolidation of analytic data for holistic view of a malware attack
    US9495180B2 (en) 2013-05-10 2016-11-15 Fireeye, Inc. Optimized resource allocation for virtual machines within a malware content detection system
    US9189318B2 (en) * 2013-05-15 2015-11-17 Oracle International Corporation Path-sensitive analysis framework for bug checking
    US10133863B2 (en) 2013-06-24 2018-11-20 Fireeye, Inc. Zero-day discovery system
    US9300686B2 (en) 2013-06-28 2016-03-29 Fireeye, Inc. System and method for detecting malicious links in electronic messages
    EP2838013A1 (en) * 2013-08-14 2015-02-18 Bitreactive AS Improved state space analysis using partial descriptions
    US9690936B1 (en) 2013-09-30 2017-06-27 Fireeye, Inc. Multistage system and method for analyzing obfuscated content for malware
    US9171160B2 (en) 2013-09-30 2015-10-27 Fireeye, Inc. Dynamically adaptive framework and method for classifying malware using intelligent static, emulation, and dynamic analyses
    US9628507B2 (en) 2013-09-30 2017-04-18 Fireeye, Inc. Advanced persistent threat (APT) detection center
    US9294501B2 (en) 2013-09-30 2016-03-22 Fireeye, Inc. Fuzzy hash of behavioral results
    US9736179B2 (en) 2013-09-30 2017-08-15 Fireeye, Inc. System, apparatus and method for using malware analysis results to drive adaptive instrumentation of virtual machines to improve exploit detection
    US9921978B1 (en) 2013-11-08 2018-03-20 Fireeye, Inc. System and method for enhanced security of storage devices
    US9747446B1 (en) 2013-12-26 2017-08-29 Fireeye, Inc. System and method for run-time object classification
    US9756074B2 (en) 2013-12-26 2017-09-05 Fireeye, Inc. System and method for IPS and VM-based detection of suspicious objects
    US9262635B2 (en) 2014-02-05 2016-02-16 Fireeye, Inc. Detection efficacy of virtual machine-based analysis with application specific events
    US10242185B1 (en) 2014-03-21 2019-03-26 Fireeye, Inc. Dynamic guest image creation and rollback
    US9591015B1 (en) 2014-03-28 2017-03-07 Fireeye, Inc. System and method for offloading packet processing and static analysis operations
    US9432389B1 (en) 2014-03-31 2016-08-30 Fireeye, Inc. System, apparatus and method for detecting a malicious attack based on static analysis of a multi-flow object
    US9223972B1 (en) 2014-03-31 2015-12-29 Fireeye, Inc. Dynamically remote tuning of a malware content detection system
    US9973531B1 (en) 2014-06-06 2018-05-15 Fireeye, Inc. Shellcode detection
    US9438623B1 (en) 2014-06-06 2016-09-06 Fireeye, Inc. Computer exploit detection using heap spray pattern matching
    US9594912B1 (en) 2014-06-06 2017-03-14 Fireeye, Inc. Return-oriented programming detection
    US10084813B2 (en) 2014-06-24 2018-09-25 Fireeye, Inc. Intrusion prevention and remedy system
    US9398028B1 (en) 2014-06-26 2016-07-19 Fireeye, Inc. System, device and method for detecting a malicious attack based on communcations between remotely hosted virtual machines and malicious web servers
    US9363280B1 (en) 2014-08-22 2016-06-07 Fireeye, Inc. System and method of detecting delivery of malware using cross-customer data
    US10027689B1 (en) 2014-09-29 2018-07-17 Fireeye, Inc. Interactive infection visualization for improved exploit detection and signature generation for malware and malware families
    US9773112B1 (en) 2014-09-29 2017-09-26 Fireeye, Inc. Exploit detection of malware and malware families
    US9690933B1 (en) 2014-12-22 2017-06-27 Fireeye, Inc. Framework for classifying an object as malicious with machine learning for deploying updated predictive models
    US10075455B2 (en) 2014-12-26 2018-09-11 Fireeye, Inc. Zero-day rotating guest image profile
    US9838417B1 (en) 2014-12-30 2017-12-05 Fireeye, Inc. Intelligent context aware user interaction for malware detection
    US10148693B2 (en) 2015-03-25 2018-12-04 Fireeye, Inc. Exploit detection system
    US9690606B1 (en) 2015-03-25 2017-06-27 Fireeye, Inc. Selective system call monitoring
    US9438613B1 (en) 2015-03-30 2016-09-06 Fireeye, Inc. Dynamic content activation for automated analysis of embedded objects
    US9483644B1 (en) 2015-03-31 2016-11-01 Fireeye, Inc. Methods for detecting file altering malware in VM based analysis
    US9514025B2 (en) * 2015-04-15 2016-12-06 International Business Machines Corporation Modeling memory use of applications
    US9594904B1 (en) 2015-04-23 2017-03-14 Fireeye, Inc. Detecting malware based on reflection
    US10176321B2 (en) 2015-09-22 2019-01-08 Fireeye, Inc. Leveraging behavior-based rules for malware family classification
    US10033747B1 (en) 2015-09-29 2018-07-24 Fireeye, Inc. System and method for detecting interpreter-based exploit attacks
    US9825976B1 (en) 2015-09-30 2017-11-21 Fireeye, Inc. Detection and classification of exploit kits
    US9825989B1 (en) 2015-09-30 2017-11-21 Fireeye, Inc. Cyber attack early warning system
    US10210329B1 (en) 2015-09-30 2019-02-19 Fireeye, Inc. Method to detect application execution hijacking using memory protection
    US10284575B2 (en) 2015-11-10 2019-05-07 Fireeye, Inc. Launcher for setting analysis environment variations for malware detection
    US10050998B1 (en) 2015-12-30 2018-08-14 Fireeye, Inc. Malicious message analysis system
    US10133866B1 (en) 2015-12-30 2018-11-20 Fireeye, Inc. System and method for triggering analysis of an object for malware in response to modification of that object
    US10341365B1 (en) 2015-12-30 2019-07-02 Fireeye, Inc. Methods and system for hiding transition events for malware detection
    US9824216B1 (en) 2015-12-31 2017-11-21 Fireeye, Inc. Susceptible environment detection system
    US10169585B1 (en) 2016-06-22 2019-01-01 Fireeye, Inc. System and methods for advanced malware detection through placement of transition events
    CN106528407B (en) * 2016-10-19 2019-01-25 中国航空综合技术研究所 A kind of embedded software safety automatic Verification system and its verification method

    Family Cites Families (17)

    * Cited by examiner, † Cited by third party
    Publication number Priority date Publication date Assignee Title
    JP4418591B2 (en) * 1998-11-03 2010-02-17 ワンスピン ソリューションズ ゲゼルシャフト ミット ベシュレンクテル ハフツングOneSpin Solutions GmbH Method and apparatus for comparing the preset characteristic and the first characteristic of the technical system
    US6292916B1 (en) * 1998-12-10 2001-09-18 Lucent Technologies Inc. Parallel backtracing for satisfiability on reconfigurable hardware
    US6539345B1 (en) * 1999-04-09 2003-03-25 Intel Corporation Symbolic simulation using input space decomposition via Boolean functional representation in parametric form
    US20030005407A1 (en) * 2000-06-23 2003-01-02 Hines Kenneth J. System and method for coordination-centric design of software systems
    US7031896B1 (en) * 2000-06-30 2006-04-18 Intel Corporation Methods for performing generalized trajectory evaluation
    US7047139B2 (en) * 2000-12-22 2006-05-16 International Business Machines Corporation Sharing information between instances of a propositional satisfiability (SAT) problem
    US6665848B2 (en) * 2001-01-12 2003-12-16 International Business Machines Corporation Time-memory tradeoff control in counterexample production
    US6944848B2 (en) * 2001-05-03 2005-09-13 International Business Machines Corporation Technique using persistent foci for finite state machine based software test generation
    US7058925B2 (en) * 2002-04-30 2006-06-06 Microsoft Corporation System and method for generating a predicate abstraction of a program
    US7089534B2 (en) * 2002-05-01 2006-08-08 International Business Machines Corporation Model based test generation for validation of parallel and concurrent software
    US7711525B2 (en) * 2002-05-30 2010-05-04 Nec Corporation Efficient approaches for bounded model checking
    US7653520B2 (en) * 2002-07-19 2010-01-26 Sri International Method for combining decision procedures with satisfiability solvers
    US6957404B2 (en) * 2002-12-20 2005-10-18 International Business Machines Corporation Model checking with layered localization reduction
    US7584455B2 (en) * 2003-10-23 2009-09-01 Microsoft Corporation Predicate-based test coverage and generation
    US7249333B2 (en) * 2005-01-18 2007-07-24 Microsoft Corporation Quantified boolean formula (QBF) solver
    US7930659B2 (en) * 2005-06-03 2011-04-19 Nec Laboratories America, Inc. Software verification
    US7784035B2 (en) * 2005-07-05 2010-08-24 Nec Laboratories America, Inc. Method for the static analysis of concurrent multi-threaded software

    Also Published As

    Publication number Publication date
    WO2005072257A2 (en) 2005-08-11
    EP1706833A2 (en) 2006-10-04
    US20050166167A1 (en) 2005-07-28
    JP2007528059A (en) 2007-10-04
    AT526628T (en) 2011-10-15
    EP1706833A4 (en) 2010-03-17
    US7346486B2 (en) 2008-03-18
    WO2005072257A3 (en) 2007-04-19

    Similar Documents

    Publication Publication Date Title
    Srivastava et al. From program verification to program synthesis
    Khurshid et al. TestEra: Specification-based testing of Java programs using SAT
    Møller et al. Difference decision diagrams
    Neighbors Software construction using components
    Cleaveland et al. The concurrency workbench
    Clarke Jr et al. Model checking
    Jhala et al. Path slicing
    Ip et al. Better verification through symmetry
    Păsăreanu et al. A survey of new trends in symbolic execution for software testing and analysis
    Hoffmann et al. Multivariate amortized resource analysis
    US6975976B1 (en) Property specific testbench generation framework for circuit design validation by guided simulation
    Weber et al. Beyond soundness: on the verification of semantic business process models
    van derWerf et al. Process discovery using integer linear programming
    Bharadwaj et al. Model checking complete requirements specifications using abstraction
    Clarke et al. Counterexample-guided abstraction refinement for symbolic model checking
    Jhala et al. Software model checking
    Cousot et al. A parametric segmentation functor for fully automatic and scalable array content analysis
    Clarke et al. Predicate abstraction of ANSI-C programs using SAT
    US6163876A (en) Method for verification of RTL generated from scheduled behavior in a high-level synthesis flow
    Dwyer et al. Tool-supported program abstraction for finite-state verification
    Burch et al. Symbolic model checking: 1020 states and beyond
    US7657867B2 (en) System and method for generating a predicate abstraction of a program
    US7383166B2 (en) Verification of scheduling in the presence of loops using uninterpreted symbolic simulation
    Polozov et al. FlashMeta: a framework for inductive program synthesis
    Dwyer et al. Flow analysis for verifying properties of concurrent software systems

    Legal Events

    Date Code Title Description
    AX Request for extension of the european patent to

    Extension state: AL BA HR LV MK YU

    17P Request for examination filed

    Effective date: 20060809

    AK Designated contracting states:

    Kind code of ref document: A2

    Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IS IT LI LT LU MC NL PL PT RO SE SI SK TR

    DAX Request for extension of the european patent (to any country) deleted
    RIC1 Classification (correction)

    Ipc: G06F 17/10 20060101ALI20070604BHEP

    Ipc: G06F 7/60 20060101ALI20070604BHEP

    Ipc: G06F 9/45 20060101AFI20070604BHEP

    Ipc: G06F 17/50 20060101ALI20070604BHEP

    A4 Despatch of supplementary search report

    Effective date: 20100212

    17Q First examination report

    Effective date: 20100902

    REG Reference to a national code

    Ref country code: DE

    Ref legal event code: R079

    Ref document number: 602005030230

    Country of ref document: DE

    Free format text: PREVIOUS MAIN CLASS: G06F0017500000

    Ipc: G06F0009450000

    RIC1 Classification (correction)

    Ipc: G06F 7/60 20060101ALI20110221BHEP

    Ipc: G06F 17/50 20060101ALI20110221BHEP

    Ipc: G06F 11/36 20060101ALN20110221BHEP

    Ipc: G06F 9/45 20060101AFI20110221BHEP

    Ipc: G06F 17/10 20060101ALI20110221BHEP

    REG Reference to a national code

    Ref country code: GB

    Ref legal event code: FG4D

    AK Designated contracting states:

    Kind code of ref document: B1

    Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IS IT LI LT LU MC NL PL PT RO SE SI SK TR

    REG Reference to a national code

    Ref country code: CH

    Ref legal event code: EP

    REG Reference to a national code

    Ref country code: IE

    Ref legal event code: FG4D

    REG Reference to a national code

    Ref country code: DE

    Ref legal event code: R096

    Ref document number: 602005030230

    Country of ref document: DE

    Effective date: 20111222

    REG Reference to a national code

    Ref country code: NL

    Ref legal event code: VDEP

    Effective date: 20110928

    RAP2 Transfer of rights of an ep granted patent

    Owner name: NEC CORPORATION

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: SE

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: FI

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: LT

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    REG Reference to a national code

    Ref country code: DE

    Ref legal event code: R082

    Ref document number: 602005030230

    Country of ref document: DE

    Representative=s name: BETTEN & RESCH, DE

    LTIE Lt: invalidation of european patent or patent extension

    Effective date: 20110928

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: CY

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: AT

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: SI

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: GR

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20111229

    REG Reference to a national code

    Ref country code: AT

    Ref legal event code: MK05

    Ref document number: 526628

    Country of ref document: AT

    Kind code of ref document: T

    Effective date: 20110928

    REG Reference to a national code

    Ref country code: DE

    Ref legal event code: R082

    Ref document number: 602005030230

    Country of ref document: DE

    Representative=s name: PATENTANWAELTE BETTEN & RESCH, DE

    Effective date: 20120207

    Ref country code: DE

    Ref legal event code: R081

    Ref document number: 602005030230

    Country of ref document: DE

    Owner name: NEC CORPORATION, JP

    Free format text: FORMER OWNER: NEC LABORATORIES AMERICA, INC., PRINCETON, US

    Effective date: 20120207

    Ref country code: DE

    Ref legal event code: R081

    Ref document number: 602005030230

    Country of ref document: DE

    Owner name: NEC CORPORATION, JP

    Free format text: FORMER OWNER: NEC LABORATORIES AMERICA, INC., PRINCETON, US

    Effective date: 20111028

    Ref country code: DE

    Ref legal event code: R081

    Ref document number: 602005030230

    Country of ref document: DE

    Owner name: NEC CORPORATION, JP

    Free format text: FORMER OWNER: NEC LABORATORIES AMERICA, INC., PRINCETON, N.J., US

    Effective date: 20120207

    Ref country code: DE

    Ref legal event code: R081

    Ref document number: 602005030230

    Country of ref document: DE

    Owner name: NEC CORPORATION, JP

    Free format text: FORMER OWNER: NEC LABORATORIES AMERICA, INC., PRINCETON, N.J., US

    Effective date: 20111028

    Ref country code: DE

    Ref legal event code: R082

    Ref document number: 602005030230

    Country of ref document: DE

    Representative=s name: BETTEN & RESCH PATENT- UND RECHTSANWAELTE PART, DE

    Effective date: 20120207

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: BE

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: IS

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20120128

    Ref country code: SK

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: CZ

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: IT

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: RO

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: PT

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20120130

    Ref country code: NL

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: EE

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    REG Reference to a national code

    Ref country code: GB

    Ref legal event code: 732E

    Free format text: REGISTERED BETWEEN 20120628 AND 20120704

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: DK

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    REG Reference to a national code

    Ref country code: CH

    Ref legal event code: PL

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: PL

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    Ref country code: MC

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20120131

    26N No opposition filed

    Effective date: 20120629

    REG Reference to a national code

    Ref country code: IE

    Ref legal event code: MM4A

    REG Reference to a national code

    Ref country code: DE

    Ref legal event code: R097

    Ref document number: 602005030230

    Country of ref document: DE

    Effective date: 20120629

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: LI

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20120131

    Ref country code: CH

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20120131

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: IE

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20120121

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: ES

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20120108

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: BG

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20111228

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: TR

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20110928

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: LU

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20120121

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: HU

    Free format text: LAPSE BECAUSE OF FAILURE TO SUBMIT A TRANSLATION OF THE DESCRIPTION OR TO PAY THE FEE WITHIN THE PRESCRIBED TIME-LIMIT

    Effective date: 20050121

    REG Reference to a national code

    Ref country code: FR

    Ref legal event code: PLFP

    Year of fee payment: 12

    PGFP Postgrant: annual fees paid to national office

    Ref country code: DE

    Payment date: 20160112

    Year of fee payment: 12

    PGFP Postgrant: annual fees paid to national office

    Ref country code: GB

    Payment date: 20160120

    Year of fee payment: 12

    REG Reference to a national code

    Ref country code: FR

    Ref legal event code: PLFP

    Year of fee payment: 13

    PGFP Postgrant: annual fees paid to national office

    Ref country code: FR

    Payment date: 20161215

    Year of fee payment: 13

    REG Reference to a national code

    Ref country code: DE

    Ref legal event code: R119

    Ref document number: 602005030230

    Country of ref document: DE

    GBPC Gb: european patent ceased through non-payment of renewal fee

    Effective date: 20170121

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: GB

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20170121

    Ref country code: DE

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20170801

    PG25 Lapsed in a contracting state announced via postgrant inform. from nat. office to epo

    Ref country code: FR

    Free format text: LAPSE BECAUSE OF NON-PAYMENT OF DUE FEES

    Effective date: 20180131

    REG Reference to a national code

    Ref country code: FR

    Ref legal event code: ST

    Effective date: 20180928