From 4752fd64563c33a2d0ba505f69ecd53a05e919f7 Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Mon, 9 May 2022 10:40:24 -0700 Subject: [PATCH 01/10] Turn on RTS options --- saw-script.cabal | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/saw-script.cabal b/saw-script.cabal index 47496b4791..4c8d7bb8d7 100644 --- a/saw-script.cabal +++ b/saw-script.cabal @@ -221,7 +221,8 @@ executable saw , cryptol-saw-core , aig - GHC-options: -O2 -Wall -Werror -threaded -fno-ignore-asserts -fno-spec-constr-count + + GHC-options: -O2 -Wall -Werror -threaded -fno-ignore-asserts -fno-spec-constr-count -rtsopts test-suite integration_tests type: exitcode-stdio-1.0 From cd21cafb583018b54e303e8df5bfca5910046890 Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Mon, 16 May 2022 09:16:26 -0700 Subject: [PATCH 02/10] Improve the metadata avalaible regarding generated proof goals. Add some a `print_proof_summary`, a `goal_num`, and a `write_goal` tactic to help during the proof exploration process. --- saw-script.cabal | 1 - src/SAWScript/Builtins.hs | 77 ++++++++++++++++++++++--- src/SAWScript/Crucible/JVM/Builtins.hs | 9 ++- src/SAWScript/Crucible/LLVM/Builtins.hs | 35 ++++++++--- src/SAWScript/Crucible/LLVM/Override.hs | 6 +- src/SAWScript/Crucible/LLVM/X86.hs | 14 ++++- src/SAWScript/Interpreter.hs | 18 +++++- src/SAWScript/Proof.hs | 16 ++--- src/SAWScript/Value.hs | 2 + 9 files changed, 144 insertions(+), 34 deletions(-) diff --git a/saw-script.cabal b/saw-script.cabal index 4c8d7bb8d7..36a3f9bd1b 100644 --- a/saw-script.cabal +++ b/saw-script.cabal @@ -221,7 +221,6 @@ executable saw , cryptol-saw-core , aig - GHC-options: -O2 -Wall -Werror -threaded -fno-ignore-asserts -fno-spec-constr-count -rtsopts test-suite integration_tests diff --git a/src/SAWScript/Builtins.hs b/src/SAWScript/Builtins.hs index d74047335d..07ffd6e128 100644 --- a/src/SAWScript/Builtins.hs +++ b/src/SAWScript/Builtins.hs @@ -424,15 +424,40 @@ print_term_depth d t = output <- liftIO $ scShowTerm sc opts' t printOutLnTop Info output +goalSummary :: ProofGoal -> String +goalSummary goal = unlines $ + [ ("Goal " ++ goalName goal ++ " (goal number " ++ (show $ goalNum goal) ++ "): " ++ goalType goal) ++ " at " ++ goalLoc goal ] ++ + if null (goalDesc goal) then [] else [ goalDesc goal ] + + +write_goal :: String -> ProofScript () +write_goal fp = + execTactic $ tacticId $ \goal -> + do opts <- getTopLevelPPOpts + sc <- getSharedContext + liftIO $ do + output <- liftIO (scShowTerm sc opts =<< propToTerm sc (goalProp goal)) + writeFile fp (unlines [goalSummary goal, output]) + print_goal :: ProofScript () print_goal = execTactic $ tacticId $ \goal -> do opts <- getTopLevelPPOpts sc <- getSharedContext output <- liftIO (scShowTerm sc opts =<< propToTerm sc (goalProp goal)) - printOutLnTop Info ("Goal " ++ goalName goal ++ " (goal number " ++ (show $ goalNum goal) ++ "):") + printOutLnTop Info (goalSummary goal) printOutLnTop Info output +print_goal_summary :: ProofScript () +print_goal_summary = + execTactic $ tacticId $ \goal -> + printOutLnTop Info (goalSummary goal) + +goal_num :: ProofScript Int +goal_num = + execTactic $ tacticId $ \goal -> + return (goalNum goal) + print_goal_depth :: Int -> ProofScript () print_goal_depth n = execTactic $ tacticId $ \goal -> @@ -915,7 +940,15 @@ provePrim script t = do io $ checkBooleanSchema (ttType t) sc <- getSharedContext prop <- io $ predicateToProp sc Universal (ttTerm t) - let goal = ProofGoal 0 "prove" "prove" prop + pos <- SV.getPosition + let goal = ProofGoal + { goalNum = 0 + , goalType = "prove" + , goalName = "prove_prim" + , goalLoc = show pos + , goalDesc = "" + , goalProp = prop + } res <- SV.runProofScript script goal Nothing "prove_prim" case res of UnfinishedProof pst -> @@ -925,15 +958,24 @@ provePrim script t = do return res proveHelper :: + String -> ProofScript () -> TypedTerm -> (Term -> TopLevel Prop) -> TopLevel Theorem -proveHelper script t f = do +proveHelper nm script t f = do prop <- f $ ttTerm t - let goal = ProofGoal 0 "prove" "prove" prop + pos <- SV.getPosition + let goal = ProofGoal + { goalNum = 0 + , goalType = "prove" + , goalName = nm + , goalLoc = show pos + , goalDesc = "" + , goalProp = prop + } opts <- rwPPOpts <$> getTopLevelRW - res <- SV.runProofScript script goal Nothing "prove_print_prim" + res <- SV.runProofScript script goal Nothing (Text.pack nm) let failProof pst = fail $ "prove: " ++ show (length (psGoals pst)) ++ " unsolved subgoal(s)\n" ++ SV.showsProofResult opts res "" @@ -950,7 +992,7 @@ provePrintPrim :: TopLevel Theorem provePrintPrim script t = do sc <- getSharedContext - proveHelper script t $ io . predicateToProp sc Universal + proveHelper "prove_print" script t $ io . predicateToProp sc Universal provePropPrim :: ProofScript () -> @@ -958,7 +1000,7 @@ provePropPrim :: TopLevel Theorem provePropPrim script t = do sc <- getSharedContext - proveHelper script t $ io . termToProp sc + proveHelper "prove_extcore" script t $ io . termToProp sc satPrim :: ProofScript () -> @@ -968,7 +1010,15 @@ satPrim script t = do io $ checkBooleanSchema (ttType t) sc <- getSharedContext prop <- io $ predicateToProp sc Existential (ttTerm t) - let goal = ProofGoal 0 "sat" "sat" prop + pos <- SV.getPosition + let goal = ProofGoal + { goalNum = 0 + , goalType = "sat" + , goalName = "sat" + , goalLoc = show pos + , goalDesc = "" + , goalProp = prop + } res <- SV.runProofScript script goal Nothing "sat" case res of InvalidProof stats cex _ -> return (SV.Sat stats cex) @@ -1439,8 +1489,17 @@ prove_core script input = do sc <- getSharedContext t <- parseCore input p <- io (termToProp sc t) + pos <- SV.getPosition opts <- rwPPOpts <$> getTopLevelRW - res <- SV.runProofScript script (ProofGoal 0 "prove" "prove" p) Nothing "prove_core" + let goal = ProofGoal + { goalNum = 0 + , goalType = "prove" + , goalName = "prove_core" + , goalLoc = show pos + , goalDesc = "" + , goalProp = p + } + res <- SV.runProofScript script goal Nothing "prove_core" let failProof pst = fail $ "prove_core: " ++ show (length (psGoals pst)) ++ " unsolved subgoal(s)\n" ++ SV.showsProofResult opts res "" diff --git a/src/SAWScript/Crucible/JVM/Builtins.hs b/src/SAWScript/Crucible/JVM/Builtins.hs index e47b536234..1e24eeaf13 100644 --- a/src/SAWScript/Crucible/JVM/Builtins.hs +++ b/src/SAWScript/Crucible/JVM/Builtins.hs @@ -290,7 +290,14 @@ verifyObligations cc mspec tactic assumes asserts = goal <- io $ scImplies sc assume assert goal' <- io $ boolToProp sc [] goal -- TODO, generalize over inputs let goalname = concat [nm, " (", takeWhile (/= '\n') msg, ")"] - proofgoal = ProofGoal n "vc" goalname goal' + proofgoal = ProofGoal + { goalNum = n + , goalType = "vc" + , goalName = nm + , goalLoc = show ploc + , goalDesc = msg + , goalProp = goal' + } res <- runProofScript tactic proofgoal (Just ploc) $ Text.unwords ["JVM verification condition:", Text.pack (show n), Text.pack goalname] case res of diff --git a/src/SAWScript/Crucible/LLVM/Builtins.hs b/src/SAWScript/Crucible/LLVM/Builtins.hs index ba1ad5e1a1..5f912279f0 100644 --- a/src/SAWScript/Crucible/LLVM/Builtins.hs +++ b/src/SAWScript/Crucible/LLVM/Builtins.hs @@ -589,7 +589,7 @@ verifyMethodSpec cc methodSpec lemmas checkSat tactic asp = io $ verifyPrestate opts cc methodSpec globals1 when (detectVacuity opts) - $ checkAssumptionsForContradictions cc tactic assumes + $ checkAssumptionsForContradictions cc methodSpec tactic assumes -- save initial path conditions frameIdent <- io $ Crucible.pushAssumptionFrame bak @@ -637,7 +637,14 @@ verifyObligations cc mspec tactic assumes asserts = do goal <- io $ scImplies sc assume assert goal' <- io $ boolToProp sc [] goal let goalname = concat [nm, " (", takeWhile (/= '\n') msg, ")"] - proofgoal = ProofGoal n "vc" goalname goal' + proofgoal = ProofGoal + { goalNum = n + , goalType = "vc" + , goalName = nm + , goalLoc = show ploc + , goalDesc = msg + , goalProp = goal' + } res <- runProofScript tactic proofgoal (Just ploc) $ Text.unwords ["LLVM verification condition", Text.pack (show n), Text.pack goalname] case res of @@ -795,10 +802,11 @@ verifyPrestate opts cc mspec globals = assumptionsContainContradiction :: (Crucible.HasPtrWidth (Crucible.ArchWidth arch), Crucible.HasLLVMAnn Sym) => LLVMCrucibleContext arch -> + MS.CrucibleMethodSpecIR (LLVM arch) -> ProofScript () -> [Crucible.LabeledPred Term AssumptionReason] -> TopLevel Bool -assumptionsContainContradiction cc tactic assumptions = +assumptionsContainContradiction cc methodSpec tactic assumptions = do let sym = cc^.ccSym st <- io $ Common.sawCoreState sym @@ -810,7 +818,14 @@ assumptionsContainContradiction cc tactic assumptions = -- implies falsehood goal <- scImplies sc assume =<< toSC sym st (W4.falsePred sym) goal' <- boolToProp sc [] goal - return $ ProofGoal 0 "vc" "vacuousness check" goal' + return $ ProofGoal + { goalNum = 0 + , goalType = "vacuousness check" + , goalName = show (methodSpec^.MS.csMethod) + , goalLoc = show (methodSpec^.MS.csLoc) + , goalDesc = "vacuousness check" + , goalProp = goal' + } res <- runProofScript tactic pgl Nothing "vacuousness check" case res of ValidProof _ _ -> return True @@ -826,16 +841,17 @@ assumptionsContainContradiction cc tactic assumptions = computeMinimalContradictingCore :: (Crucible.HasPtrWidth (Crucible.ArchWidth arch), Crucible.HasLLVMAnn Sym) => LLVMCrucibleContext arch -> + MS.CrucibleMethodSpecIR (LLVM arch) -> ProofScript () -> [Crucible.LabeledPred Term AssumptionReason] -> TopLevel () -computeMinimalContradictingCore cc tactic assumes = +computeMinimalContradictingCore cc methodSpec tactic assumes = do printOutLnTop Warn "Contradiction detected! Computing minimal core of contradictory assumptions:" -- test subsets of assumptions of increasing sizes until we find a -- contradictory one let cores = sortBy (compare `on` length) (subsequences assumes) - findM (assumptionsContainContradiction cc tactic) cores >>= \case + findM (assumptionsContainContradiction cc methodSpec tactic) cores >>= \case Nothing -> printOutLnTop Warn "No minimal core: the assumptions did not contains a contradiction." Just core -> forM_ core $ \assume -> @@ -848,13 +864,14 @@ computeMinimalContradictingCore cc tactic assumes = checkAssumptionsForContradictions :: (Crucible.HasPtrWidth (Crucible.ArchWidth arch), Crucible.HasLLVMAnn Sym) => LLVMCrucibleContext arch -> + MS.CrucibleMethodSpecIR (LLVM arch) -> ProofScript () -> [Crucible.LabeledPred Term AssumptionReason] -> TopLevel () -checkAssumptionsForContradictions cc tactic assumes = +checkAssumptionsForContradictions cc methodSpec tactic assumes = whenM - (assumptionsContainContradiction cc tactic assumes) - (computeMinimalContradictingCore cc tactic assumes) + (assumptionsContainContradiction cc methodSpec tactic assumes) + (computeMinimalContradictingCore cc methodSpec tactic assumes) -- | Check two MemTypes for register compatiblity. This is a stricter -- check than the memory compatiblity check that is done for points-to diff --git a/src/SAWScript/Crucible/LLVM/Override.hs b/src/SAWScript/Crucible/LLVM/Override.hs index f29bf1731a..58a6022ff8 100644 --- a/src/SAWScript/Crucible/LLVM/Override.hs +++ b/src/SAWScript/Crucible/LLVM/Override.hs @@ -1372,9 +1372,9 @@ matchTerm sc cc loc prepost real expect = _ -> do t <- liftIO $ scEq sc real expect let msg = unlines $ - [ "Literal equality " ++ stateCond prepost - , "Expected term: " ++ prettyTerm expect - , "Actual term: " ++ prettyTerm real + [ "Literal equality " ++ stateCond prepost ++ " at " ++ show loc +-- , "Expected term: " ++ prettyTerm expect +-- , "Actual term: " ++ prettyTerm real ] addTermEq t $ Crucible.SimError loc $ Crucible.AssertFailureSimError msg "" where prettyTerm = show . ppTermDepth 20 diff --git a/src/SAWScript/Crucible/LLVM/X86.hs b/src/SAWScript/Crucible/LLVM/X86.hs index e95786b426..3b6e44cac0 100644 --- a/src/SAWScript/Crucible/LLVM/X86.hs +++ b/src/SAWScript/Crucible/LLVM/X86.hs @@ -518,7 +518,7 @@ llvm_verify_x86_common (Some (llvmModule :: LLVMModule x)) path nm globsyms chec ar C.TimeoutResult{} -> fail "Execution timed out" - (stats,thms) <- checkGoals bak opts sc tactic + (stats,thms) <- checkGoals bak opts nm sc tactic end <- io getCurrentTime let diff = diffUTCTime end start @@ -1142,10 +1142,11 @@ checkGoals :: IsSymBackend Sym bak => bak -> Options -> + String -> SharedContext -> ProofScript () -> TopLevel (SolverStats, Set TheoremNonce) -checkGoals bak opts sc tactic = do +checkGoals bak opts nm sc tactic = do gs <- liftIO $ getGoals (SomeBackend bak) liftIO . printOutLn opts Info $ mconcat [ "Simulation finished, running solver on " @@ -1154,7 +1155,14 @@ checkGoals bak opts sc tactic = do ] outs <- forM (zip [0..] gs) $ \(n, g) -> do term <- liftIO $ gGoal sc g - let proofgoal = ProofGoal n "vc" (show $ gMessage g) term + let proofgoal = ProofGoal + { goalNum = n + , goalType = "vc" + , goalName = nm + , goalLoc = show $ gLoc g + , goalDesc = show $ gMessage g + , goalProp = term + } res <- runProofScript tactic proofgoal (Just (gLoc g)) $ Text.unwords ["X86 verification condition", Text.pack (show n), Text.pack (show (gMessage g))] case res of diff --git a/src/SAWScript/Interpreter.hs b/src/SAWScript/Interpreter.hs index 9835aca5aa..967af2de96 100644 --- a/src/SAWScript/Interpreter.hs +++ b/src/SAWScript/Interpreter.hs @@ -1454,7 +1454,23 @@ primitives = Map.fromList (pureVal print_goal) Current [ "Print the current goal that a proof script is attempting to prove." ] - + , prim "write_goal" "String -> ProofScript ()" + (pureVal write_goal) + Current + [ "Write the current goal that a proof script is attempting to prove" + , "into the named file." + ] + , prim "print_goal_summary" "ProofScript ()" + (pureVal print_goal_summary) + Current + [ "Print the number and description of the goal that a proof script" + , "is attempting to prove." + ] + , prim "goal_num" "ProofScript Int" + (pureVal goal_num) + Current + [ "Returns the number of the current proof goal." + ] , prim "print_goal_depth" "Int -> ProofScript ()" (pureVal print_goal_depth) Current diff --git a/src/SAWScript/Proof.hs b/src/SAWScript/Proof.hs index 75dc6d81b2..95ec8d875c 100644 --- a/src/SAWScript/Proof.hs +++ b/src/SAWScript/Proof.hs @@ -667,6 +667,8 @@ data ProofGoal = { goalNum :: Int , goalType :: String , goalName :: String + , goalLoc :: String + , goalDesc :: String , goalProp :: Prop } @@ -1199,12 +1201,12 @@ tacticApply sc thm = Tactic \goal -> -- | Attempt to simplify a goal by splitting it along conjunctions. If successful, -- two subgoals will be produced, representing the two conjuncts to be proved. tacticSplit :: (F.MonadFail m, MonadIO m) => SharedContext -> Tactic m () -tacticSplit sc = Tactic \(ProofGoal num ty name prop) -> - liftIO (splitProp sc prop) >>= \case +tacticSplit sc = Tactic \gl -> + liftIO (splitProp sc (goalProp gl)) >>= \case Nothing -> fail "split tactic failed: goal not a conjunction" Just (p1,p2) -> - do let g1 = ProofGoal num (ty ++ ".left") name p1 - let g2 = ProofGoal num (ty ++ ".right") name p2 + do let g1 = gl{ goalType = goalType gl ++ ".left", goalProp = p1 } + let g2 = gl{ goalType = goalType gl ++ ".right", goalProp = p2 } return ((), mempty, [g1,g2], splitEvidence) -- | Attempt to solve a goal by recognizing it as a trivially true proposition. @@ -1237,10 +1239,10 @@ tacticExact sc tm = Tactic \goal -> -- | Examine the given proof goal and potentially do some work with it, -- but do not alter the proof state. -tacticId :: Monad m => (ProofGoal -> m ()) -> Tactic m () +tacticId :: Monad m => (ProofGoal -> m a) -> Tactic m a tacticId f = Tactic \gl -> - do lift (f gl) - return ((), mempty, [gl], passthroughEvidence) + do x <- lift (f gl) + return (x, mempty, [gl], passthroughEvidence) data SolveResult = SolveSuccess Evidence diff --git a/src/SAWScript/Value.hs b/src/SAWScript/Value.hs index 9da3910473..e075aac840 100644 --- a/src/SAWScript/Value.hs +++ b/src/SAWScript/Value.hs @@ -674,6 +674,8 @@ newtype JVMSetupM a = JVMSetupM { runJVMSetupM :: JVMSetup a } newtype ProofScript a = ProofScript { unProofScript :: ExceptT (SolverStats, CEX) (StateT ProofState TopLevel) a } deriving (Functor, Applicative, Monad) +-- TODO: remove the "reason" parameter and compute it from the +-- initial proof goal instead runProofScript :: ProofScript a -> ProofGoal -> Maybe ProgramLoc -> Text -> TopLevel ProofResult runProofScript (ProofScript m) gl ploc rsn = do pos <- getPosition From 360075980a603ef5c551c741ce118a57e956c623 Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Wed, 18 May 2022 16:42:31 -0700 Subject: [PATCH 03/10] Add better tracking for the location values of LLVM points-to assertions. We should check/update the corresponding information for JVM points-tos. --- src/SAWScript/Crucible/LLVM/Builtins.hs | 3 +- src/SAWScript/Crucible/LLVM/Override.hs | 38 +++++++++++++------------ src/SAWScript/Crucible/LLVM/X86.hs | 2 +- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/src/SAWScript/Crucible/LLVM/Builtins.hs b/src/SAWScript/Crucible/LLVM/Builtins.hs index 5f912279f0..8c7bb177f1 100644 --- a/src/SAWScript/Crucible/LLVM/Builtins.hs +++ b/src/SAWScript/Crucible/LLVM/Builtins.hs @@ -1409,7 +1409,8 @@ verifyPoststate cc mspec env0 globals ret = matchResult opts sc = case (ret, mspec ^. MS.csRetValue) of - (Just (rty,r), Just expect) -> matchArg opts sc cc mspec PostState r rty expect + (Just (rty,r), Just expect) -> + matchArg opts sc cc mspec PostState (mspec ^. MS.csLoc) r rty expect (Nothing , Just _ ) -> fail "verifyPoststate: unexpected llvm_return specification" _ -> return () diff --git a/src/SAWScript/Crucible/LLVM/Override.hs b/src/SAWScript/Crucible/LLVM/Override.hs index 58a6022ff8..2b18b2d08f 100644 --- a/src/SAWScript/Crucible/LLVM/Override.hs +++ b/src/SAWScript/Crucible/LLVM/Override.hs @@ -639,7 +639,8 @@ methodSpecHandler_prestate opts sc cc args cs = -- todo: fail if list lengths mismatch xs <- liftIO (zipWithM aux expectedArgTypes (assignmentToList args)) - sequence_ [ matchArg opts sc cc cs PreState x y z | (x, y, z) <- xs] + let loc = cs ^. MS.csLoc + sequence_ [ matchArg opts sc cc cs PreState loc x y z | (x, y, z) <- xs] learnCond opts sc cc cs PreState (cs ^. MS.csGlobalAllocs) Map.empty (cs ^. MS.csPreState) @@ -1159,13 +1160,14 @@ matchArg :: LLVMCrucibleContext arch {- ^ context for interacting with Crucible -} -> MS.CrucibleMethodSpecIR (LLVM arch) {- ^ specification for current function override -} -> PrePost -> + W4.ProgramLoc -> Crucible.LLVMVal Sym {- ^ concrete simulation value -} -> Crucible.MemType {- ^ expected memory type -} -> SetupValue (LLVM arch) {- ^ expected specification value -} -> OverrideMatcher (LLVM arch) md () -matchArg opts sc cc cs prepost actual expectedTy expected = +matchArg opts sc cc cs prepost loc actual expectedTy expected = ccWithBackend cc $ \bak -> do let sym = backendGetSym bak mem <- readGlobal $ Crucible.llvmMemVar $ ccLLVMContext cc @@ -1174,20 +1176,20 @@ matchArg opts sc cc cs prepost actual expectedTy expected = | TypedTermSchema (Cryptol.Forall [] [] tyexpr) <- ttType expectedTT , Right tval <- Cryptol.evalType mempty tyexpr -> do failMsg <- mkStructuralMismatch opts cc sc cs actual expected expectedTy - realTerm <- valueToSC sym (cs ^. MS.csLoc) failMsg tval actual - instantiateExtMatchTerm sc cc (cs ^. MS.csLoc) prepost realTerm (ttTerm expectedTT) + realTerm <- valueToSC sym loc failMsg tval actual + instantiateExtMatchTerm sc cc loc prepost realTerm (ttTerm expectedTT) -- match arrays point-wise (Crucible.LLVMValArray _ xs, Crucible.ArrayType _len y, SetupArray () zs) | V.length xs >= length zs -> sequence_ - [ matchArg opts sc cc cs prepost x y z + [ matchArg opts sc cc cs prepost loc x y z | (x, z) <- zip (V.toList xs) zs ] -- match the fields of struct point-wise (Crucible.LLVMValStruct xs, Crucible.StructType fields, SetupStruct () _ zs) -> sequence_ - [ matchArg opts sc cc cs prepost x y z + [ matchArg opts sc cc cs prepost loc x y z | ((_,x),y,z) <- zip3 (V.toList xs) (V.toList (Crucible.fiType <$> Crucible.siFields fields)) zs ] @@ -1198,7 +1200,7 @@ matchArg opts sc cc cs prepost actual expectedTy expected = delta <- exceptToFail $ resolveSetupElemOffset cc tyenv nameEnv v i off' <- liftIO $ W4.bvSub sym off =<< W4.bvLit sym (W4.bvWidth off) (Crucible.bytesToBV (W4.bvWidth off) delta) - matchArg opts sc cc cs prepost (Crucible.LLVMValInt blk off') expectedTy v + matchArg opts sc cc cs prepost loc (Crucible.LLVMValInt blk off') expectedTy v (Crucible.LLVMValInt blk off, Crucible.PtrType _, SetupField () v n) -> do let tyenv = MS.csAllocations cs @@ -1209,31 +1211,31 @@ matchArg opts sc cc cs prepost actual expectedTy expected = let delta = fromIntegral $ Crucible.fiOffset fld off' <- liftIO $ W4.bvSub sym off =<< W4.bvLit sym (W4.bvWidth off) (Crucible.bytesToBV (W4.bvWidth off) delta) - matchArg opts sc cc cs prepost (Crucible.LLVMValInt blk off') expectedTy v + matchArg opts sc cc cs prepost loc (Crucible.LLVMValInt blk off') expectedTy v (_, _, SetupGlobalInitializer () _) -> resolveAndMatch (Crucible.LLVMValInt blk off, _, _) -> case expected of SetupVar var | Just Refl <- testEquality (W4.bvWidth off) Crucible.PtrWidth -> - do assignVar cc (cs ^. MS.csLoc) var (Crucible.LLVMPointer blk off) + do assignVar cc loc var (Crucible.LLVMPointer blk off) SetupNull () | Just Refl <- testEquality (W4.bvWidth off) Crucible.PtrWidth -> do p <- liftIO (Crucible.ptrIsNull sym Crucible.PtrWidth (Crucible.LLVMPointer blk off)) addAssert p =<< - notEqual prepost opts (cs ^. MS.csLoc) cc sc cs expected actual + notEqual prepost opts loc cc sc cs expected actual SetupGlobal () name | Just Refl <- testEquality (W4.bvWidth off) Crucible.PtrWidth -> do ptr2 <- liftIO $ Crucible.doResolveGlobal bak mem (L.Symbol name) pred_ <- liftIO $ Crucible.ptrEq sym Crucible.PtrWidth (Crucible.LLVMPointer blk off) ptr2 addAssert pred_ =<< - notEqual prepost opts (cs ^. MS.csLoc) cc sc cs expected actual + notEqual prepost opts loc cc sc cs expected actual - _ -> failure (cs ^. MS.csLoc) =<< + _ -> failure loc =<< mkStructuralMismatch opts cc sc cs actual expected expectedTy - _ -> failure (cs ^. MS.csLoc) =<< + _ -> failure loc =<< mkStructuralMismatch opts cc sc cs actual expected expectedTy where @@ -1241,14 +1243,14 @@ matchArg opts sc cc cs prepost actual expectedTy expected = (ty, val) <- resolveSetupValueLLVM opts cc sc cs expected sym <- Ov.getSymInterface if diffMemTypes expectedTy ty /= [] - then failure (cs ^. MS.csLoc) =<< + then failure loc =<< mkStructuralMismatch opts cc sc cs actual expected expectedTy else liftIO (Crucible.testEqual sym val actual) >>= \case - Nothing -> failure (cs ^. MS.csLoc) BadEqualityComparison + Nothing -> failure loc BadEqualityComparison Just pred_ -> addAssert pred_ =<< - notEqual prepost opts (cs ^. MS.csLoc) cc sc cs expected actual + notEqual prepost opts loc cc sc cs expected actual ------------------------------------------------------------------------ @@ -1500,7 +1502,7 @@ matchPointsToValue opts sc cc spec prepost loc maybe_cond ptr val = Nothing -> return pred_ addAssert pred_' $ Crucible.SimError loc $ Crucible.AssertFailureSimError (show $ PP.vcat badLoadSummary) "" - pure Nothing <* matchArg opts sc cc spec prepost res_val memTy val' + pure Nothing <* matchArg opts sc cc spec prepost loc res_val memTy val' _ -> do pure $ Just $ describeConcreteMemoryLoadFailure mem badLoadSummary ptr @@ -1652,7 +1654,7 @@ matchPointsToBitfieldValue opts sc cc spec prepost loc ptr bfIndex val = -- Match the selected field against the RHS value. let field_val = Crucible.LLVMValInt bfBlk bfFieldBV - pure Nothing <* matchArg opts sc cc spec prepost field_val memTy val + pure Nothing <* matchArg opts sc cc spec prepost loc field_val memTy val _ -> fail $ unlines [ "llvm_points_to_bitfield: RHS value's size must be less then or equal to bitfield's size" diff --git a/src/SAWScript/Crucible/LLVM/X86.hs b/src/SAWScript/Crucible/LLVM/X86.hs index 3b6e44cac0..438438975e 100644 --- a/src/SAWScript/Crucible/LLVM/X86.hs +++ b/src/SAWScript/Crucible/LLVM/X86.hs @@ -1058,7 +1058,7 @@ assertPost globals env premem preregs = do _ -> pure $ C.LLVM.LLVMValInt base off _ -> throwX86 "Width of return type is zero bits" postRAXTrunc <- viewSome truncateRAX (mkNatRepr retTyBits) - pure [LO.matchArg opts sc cc ms MS.PostState postRAXTrunc retTy expectedRet] + pure [LO.matchArg opts sc cc ms MS.PostState (ms ^. MS.csLoc) postRAXTrunc retTy expectedRet] _ -> throwX86 $ "Invalid return type: " <> show (C.LLVM.ppMemType retTy) _ -> pure [] From 4f155815a94007354cf0f6e61a0da47e75c04abf Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Wed, 18 May 2022 16:45:08 -0700 Subject: [PATCH 04/10] Fix some bugs with the position tracking inside the SAWScript interpreter. --- src/SAWScript/Interpreter.hs | 6 +++--- src/SAWScript/Value.hs | 18 +++++++++--------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/SAWScript/Interpreter.hs b/src/SAWScript/Interpreter.hs index 967af2de96..474355b76e 100644 --- a/src/SAWScript/Interpreter.hs +++ b/src/SAWScript/Interpreter.hs @@ -260,9 +260,9 @@ interpretStmts env stmts = let ?fileReader = BS.readFile in case stmts of [] -> fail "empty block" - [SS.StmtBind _ (SS.PWild _) _ e] -> interpret env e - SS.StmtBind pos pat _ e : ss -> - do v1 <- interpret env e + [SS.StmtBind pos (SS.PWild _) _ e] -> withPosition pos (interpret env e) + SS.StmtBind pos pat _mcxt e : ss -> + do v1 <- withPosition pos (interpret env e) let f v = interpretStmts (bindPatternLocal pat Nothing v env) ss bindValue pos v1 (VLambda f) SS.StmtLet _ bs : ss -> interpret env (SS.Let bs (SS.Block ss)) diff --git a/src/SAWScript/Value.hs b/src/SAWScript/Value.hs index e075aac840..56ae4fc044 100644 --- a/src/SAWScript/Value.hs +++ b/src/SAWScript/Value.hs @@ -769,8 +769,8 @@ instance IsValue a => IsValue (TopLevel a) where instance FromValue a => FromValue (TopLevel a) where fromValue (VTopLevel action) = fmap fromValue action fromValue (VReturn v) = return (fromValue v) - fromValue (VBind _pos m1 v2) = do - v1 <- fromValue m1 + fromValue (VBind pos m1 v2) = do + v1 <- withPosition pos (fromValue m1) m2 <- applyValue v2 v1 fromValue m2 fromValue _ = error "fromValue TopLevel" @@ -781,10 +781,10 @@ instance IsValue a => IsValue (ProofScript a) where instance FromValue a => FromValue (ProofScript a) where fromValue (VProofScript m) = fmap fromValue m fromValue (VReturn v) = return (fromValue v) - fromValue (VBind _pos m1 v2) = do - v1 <- fromValue m1 - m2 <- scriptTopLevel $ applyValue v2 v1 - fromValue m2 + fromValue (VBind pos m1 v2) = ProofScript $ do + v1 <- underExceptT (underStateT (withPosition pos)) (unProofScript (fromValue m1)) + m2 <- lift $ lift $ applyValue v2 v1 + unProofScript (fromValue m2) fromValue _ = error "fromValue ProofScript" --------------------------------------------------------------------------------- @@ -798,7 +798,7 @@ instance FromValue a => FromValue (LLVMCrucibleSetupM a) where -- TODO: Should both of these be run with the new position? v1 <- underStateT (withPosition pos) (runLLVMCrucibleSetupM (fromValue m1)) m2 <- lift $ applyValue v2 v1 - underStateT (withPosition pos) (runLLVMCrucibleSetupM (fromValue m2)) + runLLVMCrucibleSetupM (fromValue m2) fromValue _ = error "fromValue CrucibleSetup" instance IsValue a => IsValue (JVMSetupM a) where @@ -807,8 +807,8 @@ instance IsValue a => IsValue (JVMSetupM a) where instance FromValue a => FromValue (JVMSetupM a) where fromValue (VJVMSetup m) = fmap fromValue m fromValue (VReturn v) = return (fromValue v) - fromValue (VBind _pos m1 v2) = JVMSetupM $ do - v1 <- runJVMSetupM (fromValue m1) + fromValue (VBind pos m1 v2) = JVMSetupM $ do + v1 <- underStateT (withPosition pos) (runJVMSetupM (fromValue m1)) m2 <- lift $ applyValue v2 v1 runJVMSetupM (fromValue m2) fromValue _ = error "fromValue JVMSetup" From 31fa250ee5c4de4be31eb61352be72b6751ab6f3 Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Wed, 18 May 2022 17:04:09 -0700 Subject: [PATCH 05/10] Better formatting for some location values --- src/SAWScript/Crucible/LLVM/Builtins.hs | 5 +++-- src/SAWScript/Crucible/LLVM/Override.hs | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/SAWScript/Crucible/LLVM/Builtins.hs b/src/SAWScript/Crucible/LLVM/Builtins.hs index 8c7bb177f1..38216bf027 100644 --- a/src/SAWScript/Crucible/LLVM/Builtins.hs +++ b/src/SAWScript/Crucible/LLVM/Builtins.hs @@ -641,7 +641,7 @@ verifyObligations cc mspec tactic assumes asserts = { goalNum = n , goalType = "vc" , goalName = nm - , goalLoc = show ploc + , goalLoc = show (W4.plSourceLoc ploc) ++ " in " ++ show (W4.plFunction ploc) , goalDesc = msg , goalProp = goal' } @@ -811,6 +811,7 @@ assumptionsContainContradiction cc methodSpec tactic assumptions = let sym = cc^.ccSym st <- io $ Common.sawCoreState sym let sc = saw_ctx st + let ploc = methodSpec^.MS.csLoc pgl <- io $ do -- conjunction of all assumptions @@ -822,7 +823,7 @@ assumptionsContainContradiction cc methodSpec tactic assumptions = { goalNum = 0 , goalType = "vacuousness check" , goalName = show (methodSpec^.MS.csMethod) - , goalLoc = show (methodSpec^.MS.csLoc) + , goalLoc = show (W4.plSourceLoc ploc) ++ " in " ++ show (W4.plFunction ploc) , goalDesc = "vacuousness check" , goalProp = goal' } diff --git a/src/SAWScript/Crucible/LLVM/Override.hs b/src/SAWScript/Crucible/LLVM/Override.hs index 2b18b2d08f..c57a4e3410 100644 --- a/src/SAWScript/Crucible/LLVM/Override.hs +++ b/src/SAWScript/Crucible/LLVM/Override.hs @@ -1374,12 +1374,12 @@ matchTerm sc cc loc prepost real expect = _ -> do t <- liftIO $ scEq sc real expect let msg = unlines $ - [ "Literal equality " ++ stateCond prepost ++ " at " ++ show loc + [ "Literal equality " ++ stateCond prepost -- , "Expected term: " ++ prettyTerm expect -- , "Actual term: " ++ prettyTerm real ] addTermEq t $ Crucible.SimError loc $ Crucible.AssertFailureSimError msg "" - where prettyTerm = show . ppTermDepth 20 +-- where prettyTerm = show . ppTermDepth 20 ------------------------------------------------------------------------ From bf5dd741c9161c3c1d8af73218ac9a9cbf229992 Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Thu, 19 May 2022 14:01:25 -0700 Subject: [PATCH 06/10] Implement `llvm_assert` and `jvm_assert`. Fixes #1644 --- src/SAWScript/Crucible/JVM/Builtins.hs | 6 ++++++ src/SAWScript/Crucible/LLVM/Builtins.hs | 7 +++++++ src/SAWScript/Interpreter.hs | 16 ++++++++++++++++ 3 files changed, 29 insertions(+) diff --git a/src/SAWScript/Crucible/JVM/Builtins.hs b/src/SAWScript/Crucible/JVM/Builtins.hs index 1e24eeaf13..b71123f344 100644 --- a/src/SAWScript/Crucible/JVM/Builtins.hs +++ b/src/SAWScript/Crucible/JVM/Builtins.hs @@ -31,6 +31,7 @@ module SAWScript.Crucible.JVM.Builtins , jvm_execute_func , jvm_postcond , jvm_precond + , jvm_assert , jvm_modifies_field , jvm_modifies_static_field , jvm_modifies_elem @@ -1255,6 +1256,11 @@ generic_array_is ptr mval = X.throwM $ JVMArrayModifyPrestate ptr' Setup.addPointsTo pt +jvm_assert :: TypedTerm -> JVMSetupM () +jvm_assert term = JVMSetupM $ do + loc <- SS.toW4Loc "jvm_assert" <$> lift getPosition + Setup.addCondition (MS.SetupCond_Pred loc term) + jvm_precond :: TypedTerm -> JVMSetupM () jvm_precond term = JVMSetupM $ do loc <- SS.toW4Loc "jvm_precond" <$> lift getPosition diff --git a/src/SAWScript/Crucible/LLVM/Builtins.hs b/src/SAWScript/Crucible/LLVM/Builtins.hs index 38216bf027..f8eabbff75 100644 --- a/src/SAWScript/Crucible/LLVM/Builtins.hs +++ b/src/SAWScript/Crucible/LLVM/Builtins.hs @@ -30,6 +30,7 @@ module SAWScript.Crucible.LLVM.Builtins , llvm_return , llvm_precond , llvm_postcond + , llvm_assert , llvm_cfg , llvm_extract , llvm_compositional_extract @@ -1732,6 +1733,12 @@ checkMemTypeCompatibility loc t1 t2 = -------------------------------------------------------------------------------- -- Setup builtins +llvm_assert :: TypedTerm -> LLVMCrucibleSetupM () +llvm_assert term = + LLVMCrucibleSetupM $ + do loc <- getW4Position "llvm_assert" + Setup.addCondition (MS.SetupCond_Pred loc term) + llvm_precond :: TypedTerm -> LLVMCrucibleSetupM () llvm_precond term = LLVMCrucibleSetupM $ diff --git a/src/SAWScript/Interpreter.hs b/src/SAWScript/Interpreter.hs index 474355b76e..14606c455d 100644 --- a/src/SAWScript/Interpreter.hs +++ b/src/SAWScript/Interpreter.hs @@ -2639,6 +2639,14 @@ primitives = Map.fromList Current [ "Legacy alternative name for `llvm_precond`." ] + , prim "llvm_assert" "Term -> LLVMSetup ()" + (pureVal llvm_assert) + Current + [ "State that the given predicate must hold. Acts as `llvm_precond`" + , "or `llvm_postcond` depending on the phase of specification in which" + , "it appears (i.e., before or after `llvm_execute_func`." + ] + , prim "llvm_postcond" "Term -> LLVMSetup ()" (pureVal llvm_postcond) Current @@ -3145,6 +3153,14 @@ primitives = Map.fromList , "method being verified." ] + , prim "jvm_assert" "Term -> JVMSetup ()" + (pureVal jvm_assert) + Current + [ "State that the given predicate must hold. Acts as `jvm_precond`" + , "or `jvm_postcond` depending on the phase of specification in which" + , "it appears (i.e., before or after `jvm_execute_func`." + ] + , prim "jvm_postcond" "Term -> JVMSetup ()" (pureVal jvm_postcond) Current From 0b8eed41c69e401ad6b4ed02280c0d4c24f42236 Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Thu, 19 May 2022 15:10:34 -0700 Subject: [PATCH 07/10] Allow the user to configure what solver to use of path satisfiability checking. --- src/SAWScript/Builtins.hs | 9 +++++++++ src/SAWScript/Crucible/Common.hs | 23 +++++++++++++++++++---- src/SAWScript/Crucible/JVM/Builtins.hs | 3 ++- src/SAWScript/Crucible/JVM/BuiltinsJVM.hs | 3 ++- src/SAWScript/Crucible/LLVM/Builtins.hs | 4 +++- src/SAWScript/Crucible/LLVM/X86.hs | 4 +++- src/SAWScript/Interpreter.hs | 8 ++++++++ src/SAWScript/Value.hs | 3 +++ src/SAWScript/X86.hs | 6 ++++-- 9 files changed, 53 insertions(+), 10 deletions(-) diff --git a/src/SAWScript/Builtins.hs b/src/SAWScript/Builtins.hs index 07ffd6e128..5d435c067c 100644 --- a/src/SAWScript/Builtins.hs +++ b/src/SAWScript/Builtins.hs @@ -30,6 +30,7 @@ import Data.Monoid import Control.Monad.Except (MonadError(..)) import Control.Monad.State import qualified Control.Exception as Ex +import Data.Char (toLower) import qualified Data.ByteString as StrictBS import qualified Data.ByteString.Lazy as BS import qualified Data.ByteString.Lazy.UTF8 as B @@ -116,6 +117,7 @@ import SAWScript.ImportAIG import SAWScript.AST (getVal, pShow, Located(..)) import SAWScript.Options as Opts import SAWScript.Proof +import SAWScript.Crucible.Common (PathSatSolver(..)) import SAWScript.TopLevel import qualified SAWScript.Value as SV import SAWScript.Value (ProofScript, printOutLnTop, AIGNetwork) @@ -1742,6 +1744,13 @@ approxmc t = do [l] -> io $ putStrLn l _ -> fail $ "Garbled result from approxmc\n\n" ++ out +set_path_sat_solver :: String -> TopLevel () +set_path_sat_solver nm = + case map toLower nm of + "z3" -> modify (\rw -> rw{ rwPathSatSolver = PathSat_Z3 }) + "yices" -> modify (\rw -> rw{ rwPathSatSolver = PathSat_Yices }) + _ -> fail $ "Unknown path sat solver: " ++ show nm + summarize_verification :: TopLevel () summarize_verification = do values <- rwProofs <$> getTopLevelRW diff --git a/src/SAWScript/Crucible/Common.hs b/src/SAWScript/Crucible/Common.hs index aee8885da6..4d27e816e4 100644 --- a/src/SAWScript/Crucible/Common.hs +++ b/src/SAWScript/Crucible/Common.hs @@ -18,6 +18,7 @@ module SAWScript.Crucible.Common , IsSymBackend(..) , HasSymInterface(..) , OnlineSolver(..) + , PathSatSolver(..) , setupProfiling , SAWCruciblePersonality(..) , newSAWCoreExprBuilder @@ -38,6 +39,7 @@ import Lang.Crucible.Backend.Online (OnlineBackend, newOnlineBackend) import qualified Data.Parameterized.Nonce as Nonce import What4.Protocol.Online (OnlineSolver(..)) import qualified What4.Solver.Z3 as Z3 +import qualified What4.Solver.Yices as Yices import qualified What4.Protocol.SMTLib2 as SMT2 import qualified What4.Config as W4 @@ -54,6 +56,12 @@ import qualified Prettyprinter as PP import Verifier.SAW.SharedTerm as SC import Verifier.SAW.Simulator.What4.ReturnTrip (SAWCoreState, newSAWCoreState) +data PathSatSolver + = PathSat_Z3 + | PathSat_Yices + deriving (Eq, Ord, Show) + + -- | The symbolic backend we use for SAW verification type Sym = W4.ExprBuilder Nonce.GlobalNonceGenerator SAWCoreState (W4.Flags W4.FloatReal) type Backend solver = OnlineBackend solver Nonce.GlobalNonceGenerator SAWCoreState (W4.Flags W4.FloatReal) @@ -75,11 +83,18 @@ newSAWCoreExprBuilder sc = defaultSAWCoreBackendTimeout :: Integer defaultSAWCoreBackendTimeout = 10000 -newSAWCoreBackend :: Sym -> IO SomeOnlineBackend -newSAWCoreBackend sym = newSAWCoreBackendWithTimeout sym 0 +newSAWCoreBackend :: PathSatSolver -> Sym -> IO SomeOnlineBackend +newSAWCoreBackend pss sym = newSAWCoreBackendWithTimeout pss sym 0 + +newSAWCoreBackendWithTimeout :: PathSatSolver -> Sym -> Integer -> IO SomeOnlineBackend +newSAWCoreBackendWithTimeout PathSat_Yices sym timeout = + do bak <- newOnlineBackend sym Yices.yicesDefaultFeatures + W4.extendConfig Yices.yicesOptions (W4.getConfiguration sym) + yicesTimeoutSetting <- W4.getOptionSetting Yices.yicesGoalTimeout (W4.getConfiguration sym) + _ <- W4.setOpt yicesTimeoutSetting timeout + return (SomeOnlineBackend (bak :: Backend Yices.Connection)) -newSAWCoreBackendWithTimeout :: Sym -> Integer -> IO SomeOnlineBackend -newSAWCoreBackendWithTimeout sym timeout = +newSAWCoreBackendWithTimeout PathSat_Z3 sym timeout = do bak <- newOnlineBackend sym (SMT2.defaultFeatures Z3.Z3) W4.extendConfig Z3.z3Options (W4.getConfiguration sym) z3TimeoutSetting <- W4.getOptionSetting Z3.z3Timeout (W4.getConfiguration sym) diff --git a/src/SAWScript/Crucible/JVM/Builtins.hs b/src/SAWScript/Crucible/JVM/Builtins.hs index b71123f344..47eddaa93a 100644 --- a/src/SAWScript/Crucible/JVM/Builtins.hs +++ b/src/SAWScript/Crucible/JVM/Builtins.hs @@ -771,8 +771,9 @@ setupCrucibleContext jclass = jc <- getJVMTrans cb <- getJavaCodebase sc <- getSharedContext + pathSatSolver <- gets rwPathSatSolver sym <- io $ newSAWCoreExprBuilder sc - bak <- io $ newSAWCoreBackend sym + bak <- io $ newSAWCoreBackend pathSatSolver sym opts <- getOptions io $ CJ.setSimulatorVerbosity (simVerbose opts) sym diff --git a/src/SAWScript/Crucible/JVM/BuiltinsJVM.hs b/src/SAWScript/Crucible/JVM/BuiltinsJVM.hs index 1b69da1b01..f8244ab6bc 100644 --- a/src/SAWScript/Crucible/JVM/BuiltinsJVM.hs +++ b/src/SAWScript/Crucible/JVM/BuiltinsJVM.hs @@ -138,6 +138,7 @@ jvm_extract c mname = do sc <- getSharedContext cb <- getJavaCodebase opts <- getOptions + pathSatSolver <- gets rwPathSatSolver let verbosity = simVerbose opts let gen = Nonce.globalNonceGenerator @@ -159,7 +160,7 @@ jvm_extract c mname = do io $ do -- only the IO monad, nothing else sym <- newSAWCoreExprBuilder sc - SomeOnlineBackend bak <- newSAWCoreBackend sym + SomeOnlineBackend bak <- newSAWCoreBackend pathSatSolver sym st <- sawCoreState sym CJ.setSimulatorVerbosity verbosity sym diff --git a/src/SAWScript/Crucible/LLVM/Builtins.hs b/src/SAWScript/Crucible/LLVM/Builtins.hs index f8eabbff75..de29045535 100644 --- a/src/SAWScript/Crucible/LLVM/Builtins.hs +++ b/src/SAWScript/Crucible/LLVM/Builtins.hs @@ -1438,6 +1438,7 @@ setupLLVMCrucibleContext pathSat lm action = what4HashConsing <- gets rwWhat4HashConsing laxPointerOrdering <- gets rwLaxPointerOrdering laxLoadsAndStores <- gets rwLaxLoadsAndStores + pathSatSolver <- gets rwPathSatSolver what4Eval <- gets rwWhat4Eval allocSymInitCheck <- gets rwAllocSymInitCheck crucibleTimeout <- gets rwCrucibleTimeout @@ -1456,7 +1457,8 @@ setupLLVMCrucibleContext pathSat lm action = io $ do let verbosity = simVerbose opts sym <- Common.newSAWCoreExprBuilder sc - Common.SomeOnlineBackend bak <- Common.newSAWCoreBackendWithTimeout sym crucibleTimeout + Common.SomeOnlineBackend bak <- + Common.newSAWCoreBackendWithTimeout pathSatSolver sym crucibleTimeout let cfg = W4.getConfiguration sym verbSetting <- W4.getOptionSetting W4.verbosity cfg diff --git a/src/SAWScript/Crucible/LLVM/X86.hs b/src/SAWScript/Crucible/LLVM/X86.hs index 438438975e..e90c3688fd 100644 --- a/src/SAWScript/Crucible/LLVM/X86.hs +++ b/src/SAWScript/Crucible/LLVM/X86.hs @@ -338,6 +338,7 @@ llvm_verify_x86_common (Some (llvmModule :: LLVMModule x)) path nm globsyms chec $ modTrans llvmModule ^. C.LLVM.transContext = do start <- io getCurrentTime laxLoadsAndStores <- gets rwLaxLoadsAndStores + pathSatSolver <- gets rwPathSatSolver let ?ptrWidth = knownNat @64 let ?memOpts = C.LLVM.defaultMemOptions { C.LLVM.laxLoadsAndStores = laxLoadsAndStores @@ -348,7 +349,8 @@ llvm_verify_x86_common (Some (llvmModule :: LLVMModule x)) path nm globsyms chec basic_ss <- getBasicSS rw <- getTopLevelRW sym <- liftIO $ newSAWCoreExprBuilder sc - SomeOnlineBackend bak <- liftIO $ newSAWCoreBackendWithTimeout sym $ rwCrucibleTimeout rw + SomeOnlineBackend bak <- liftIO $ + newSAWCoreBackendWithTimeout pathSatSolver sym $ rwCrucibleTimeout rw cacheTermsSetting <- liftIO $ W4.getOptionSetting W4.B.cacheTerms $ W4.getConfiguration sym _ <- liftIO $ W4.setOpt cacheTermsSetting $ rwWhat4HashConsingX86 rw liftIO $ W4.extendConfig diff --git a/src/SAWScript/Interpreter.hs b/src/SAWScript/Interpreter.hs index 14606c455d..e9a47983b9 100644 --- a/src/SAWScript/Interpreter.hs +++ b/src/SAWScript/Interpreter.hs @@ -494,6 +494,7 @@ buildTopLevelEnv proxy opts = , rwStackBaseAlign = defaultStackBaseAlign , rwAllocSymInitCheck = True , rwCrucibleTimeout = CC.defaultSAWCoreBackendTimeout + , rwPathSatSolver = CC.PathSat_Z3 } return (bic, ro0, rw0) @@ -870,6 +871,13 @@ primitives = Map.fromList Current [ "Disable relaxed validity checking for memory loads and stores in Crucible." ] + , prim "set_path_sat_solver" "String -> TopLevel ()" + (pureVal set_path_sat_solver) + Experimental + [ "Set the path satisfiablity solver to use. Accepted values" + , "currently are 'z3' and 'yices'." + ] + , prim "enable_debug_intrinsics" "TopLevel ()" (pureVal enable_debug_intrinsics) Current diff --git a/src/SAWScript/Value.hs b/src/SAWScript/Value.hs index 56ae4fc044..942cda2b3f 100644 --- a/src/SAWScript/Value.hs +++ b/src/SAWScript/Value.hs @@ -63,6 +63,7 @@ import qualified Data.AIG as AIG import qualified SAWScript.AST as SS import qualified SAWScript.Exceptions as SS import qualified SAWScript.Position as SS +import qualified SAWScript.Crucible.Common as Common import qualified SAWScript.Crucible.Common.Setup.Type as Setup import qualified SAWScript.Crucible.Common.MethodSpec as CMS import qualified SAWScript.Crucible.LLVM.MethodSpecIR as CMSLLVM @@ -459,6 +460,8 @@ data TopLevelRW = , rwAllocSymInitCheck :: Bool , rwCrucibleTimeout :: Integer + + , rwPathSatSolver :: Common.PathSatSolver } newtype TopLevel a = diff --git a/src/SAWScript/X86.hs b/src/SAWScript/X86.hs index ce90faef4b..b02cf498ff 100644 --- a/src/SAWScript/X86.hs +++ b/src/SAWScript/X86.hs @@ -138,6 +138,7 @@ import SAWScript.Proof(boolToProp, Prop) import SAWScript.Crucible.Common ( newSAWCoreBackend, newSAWCoreExprBuilder , sawCoreState, SomeOnlineBackend(..) + , PathSatSolver ) @@ -191,19 +192,20 @@ type CallHandler = Sym -> Macaw.LookupFunctionHandle (MacawSimulatorState Sym) S -- Should be used when making a standalone proof script. proof :: (FilePath -> IO ByteString) -> + PathSatSolver -> ArchitectureInfo X86_64 -> FilePath {- ^ ELF binary -} -> Maybe FilePath {- ^ Cryptol spec, if any -} -> [(ByteString,Integer,Unit)] -> Fun -> IO (SharedContext,Integer,[Goal]) -proof fileReader archi file mbCry globs fun = +proof fileReader pss archi file mbCry globs fun = do sc <- mkSharedContext halloc <- newHandleAllocator scLoadPreludeModule sc scLoadCryptolModule sc sym <- newSAWCoreExprBuilder sc - SomeOnlineBackend bak <- newSAWCoreBackend sym + SomeOnlineBackend bak <- newSAWCoreBackend pss sym let ?fileReader = fileReader cenv <- loadCry sym mbCry mvar <- mkMemVar "saw_x86:llvm_memory" halloc From e64a71dbe753c0c187c1e49304b5a2e85e4046fb Mon Sep 17 00:00:00 2001 From: Robert Dockins Date: Thu, 19 May 2022 15:28:56 -0700 Subject: [PATCH 08/10] Allow the user to skip safety proofs that arise during symbolic execution. This is generally unsound, but may be useful in proof exploration and construction to focus in on just the stated correcness specifications. --- src/SAWScript/Crucible/JVM/Builtins.hs | 7 ++++++ src/SAWScript/Crucible/LLVM/Builtins.hs | 16 +++++++++++--- src/SAWScript/Interpreter.hs | 29 +++++++++++++++++++++++++ src/SAWScript/Value.hs | 1 + 4 files changed, 50 insertions(+), 3 deletions(-) diff --git a/src/SAWScript/Crucible/JVM/Builtins.hs b/src/SAWScript/Crucible/JVM/Builtins.hs index 47eddaa93a..8f33a31d35 100644 --- a/src/SAWScript/Crucible/JVM/Builtins.hs +++ b/src/SAWScript/Crucible/JVM/Builtins.hs @@ -725,6 +725,13 @@ verifyPoststate cc mspec env0 globals ret = poststateLoc <- SS.toW4Loc "_SAW_verify_poststate" <$> getPosition io $ W4.setCurrentProgramLoc sym poststateLoc + -- This discards all the obligations generated during + -- symbolic execution itself, i.e., which are not directly + -- generated from specification postconditions. This + -- is, in general, unsound. + skipSafetyProofs <- gets rwSkipSafetyProofs + when skipSafetyProofs (io (Crucible.clearProofObligations bak)) + let ecs0 = Map.fromList [ (ecVarIndex ec, ec) | tt <- mspec ^. MS.csPreState . MS.csFreshVars diff --git a/src/SAWScript/Crucible/LLVM/Builtins.hs b/src/SAWScript/Crucible/LLVM/Builtins.hs index de29045535..43a3863ecf 100644 --- a/src/SAWScript/Crucible/LLVM/Builtins.hs +++ b/src/SAWScript/Crucible/LLVM/Builtins.hs @@ -1369,6 +1369,13 @@ verifyPoststate cc mspec env0 globals ret = opts <- getOptions io $ W4.setCurrentProgramLoc sym poststateLoc + -- This discards all the obligations generated during + -- symbolic execution itself, i.e., which are not directly + -- generated from specification postconditions. This + -- is, in general, unsound. + skipSafetyProofs <- gets rwSkipSafetyProofs + when skipSafetyProofs (io (Crucible.clearProofObligations bak)) + let ecs0 = Map.fromList [ (ecVarIndex ec, ec) | tt <- mspec ^. MS.csPreState . MS.csFreshVars @@ -1394,9 +1401,12 @@ verifyPoststate cc mspec env0 globals ret = io $ for_ (view osAsserts st) $ \(W4.LabeledPred p r) -> Crucible.addAssertion bak (Crucible.LabeledPred p r) - obligations <- io $ Crucible.getProofObligations bak - io $ Crucible.clearProofObligations bak - sc_obligations <- io $ mapM (verifyObligation sc) (maybe [] Crucible.goalsToList obligations) + obligations <- io $ + do obls <- Crucible.getProofObligations bak + Crucible.clearProofObligations bak + return (maybe [] Crucible.goalsToList obls) + + sc_obligations <- io $ mapM (verifyObligation sc) obligations return (sc_obligations, st) where diff --git a/src/SAWScript/Interpreter.hs b/src/SAWScript/Interpreter.hs index e9a47983b9..06ffcdfc35 100644 --- a/src/SAWScript/Interpreter.hs +++ b/src/SAWScript/Interpreter.hs @@ -495,6 +495,7 @@ buildTopLevelEnv proxy opts = , rwAllocSymInitCheck = True , rwCrucibleTimeout = CC.defaultSAWCoreBackendTimeout , rwPathSatSolver = CC.PathSat_Z3 + , rwSkipSafetyProofs = False } return (bic, ro0, rw0) @@ -525,6 +526,18 @@ add_primitives lc bic opts = do , rwPrimsAvail = Set.insert lc (rwPrimsAvail rw) } +enable_safety_proofs :: TopLevel () +enable_safety_proofs = do + rw <- getTopLevelRW + putTopLevelRW rw{ rwSkipSafetyProofs = False } + +disable_safety_proofs :: TopLevel () +disable_safety_proofs = do + opts <- getOptions + io $ printOutLn opts Warn "Safety proofs disabled! This is unsound!" + rw <- getTopLevelRW + putTopLevelRW rw{ rwSkipSafetyProofs = True } + enable_smt_array_memory_model :: TopLevel () enable_smt_array_memory_model = do rw <- getTopLevelRW @@ -831,6 +844,22 @@ primitives = Map.fromList Current [ "Disable the SMT array memory model." ] + , prim "enable_safety_proofs" "TopLevel ()" + (pureVal enable_safety_proofs) + Experimental + [ "Restore the default state, where safety obligations" + , "encountered during symbolic execution are proofed normally." + ] + + , prim "disable_safety_proofs" "TopLevel ()" + (pureVal disable_safety_proofs) + Experimental + [ "Disable checking of safety obligations encountered during symbolic" + , "execution. This is unsound! However, it can be useful during" + , "initial proof construction to focus only on the stated correcness" + , "specifications." + ] + , prim "enable_crucible_assert_then_assume" "TopLevel ()" (pureVal enable_crucible_assert_then_assume) Current diff --git a/src/SAWScript/Value.hs b/src/SAWScript/Value.hs index 942cda2b3f..bdbc167e36 100644 --- a/src/SAWScript/Value.hs +++ b/src/SAWScript/Value.hs @@ -462,6 +462,7 @@ data TopLevelRW = , rwCrucibleTimeout :: Integer , rwPathSatSolver :: Common.PathSatSolver + , rwSkipSafetyProofs :: Bool } newtype TopLevel a = From 0180824a99117977a150de5a45bc7b5162694633 Mon Sep 17 00:00:00 2001 From: Rob Dockins Date: Fri, 20 May 2022 10:12:29 -0700 Subject: [PATCH 09/10] Update manual --- doc/manual/manual.md | 60 ++++++++++++++++++++++-------------------- doc/manual/manual.pdf | Bin 475947 -> 475852 bytes 2 files changed, 32 insertions(+), 28 deletions(-) diff --git a/doc/manual/manual.md b/doc/manual/manual.md index 2661c3cf9a..967b438949 100644 --- a/doc/manual/manual.md +++ b/doc/manual/manual.md @@ -1886,7 +1886,7 @@ llvm_verify : String -> [CrucibleMethodSpec] -> Bool -> - CrucibleSetup () -> + LLVMSetup () -> ProofScript SatResult -> TopLevel CrucibleMethodSpec ~~~~ @@ -1915,7 +1915,7 @@ jvm_verify : TopLevel JVMMethodSpec ~~~~ -Now we describe how to construct a value of type `CrucibleSetup ()` (or +Now we describe how to construct a value of type `LLVMSetup ()` (or `JVMSetup ()`). ## Structure of a Specification @@ -1929,7 +1929,7 @@ A specifications for Crucible consists of three logical components: * A specification of the expected final value of the program state. These three portions of the specification are written in sequence within -a `do` block of `CrucibleSetup` (or `JVMSetup`) type. The command +a `do` block of `LLVMSetup` (or `JVMSetup`) type. The command `llvm_execute_func` (or `jvm_execute_func`) separates the specification of the initial state from the specification of the final state, and specifies the arguments to the function in terms of the @@ -1946,7 +1946,7 @@ contain fresh variables. These are created in a specification with the `llvm_fresh_var` and `jvm_fresh_var` commands rather than `fresh_symbolic`. -* `llvm_fresh_var : String -> LLVMType -> CrucibleSetup Term` +* `llvm_fresh_var : String -> LLVMType -> LLVMSetup Term` * `jvm_fresh_var : String -> JavaType -> JVMSetup Term` @@ -2022,14 +2022,14 @@ Once the initial state has been configured, the `llvm_execute_func` command specifies the parameters of the function being analyzed in terms of the state elements already configured. -* `llvm_execute_func : [SetupValue] -> CrucibleSetup ()` +* `llvm_execute_func : [SetupValue] -> LLVMSetup ()` ## Return Values To specify the value that should be returned by the function being verified use the `llvm_return` or `jvm_return` command. -* `llvm_return : SetupValue -> CrucibleSetup ()` +* `llvm_return : SetupValue -> LLVMSetup ()` * `jvm_return : JVMValue -> JVMSetup ()` ## A First Simple Example @@ -2076,7 +2076,7 @@ and more complex systems than otherwise possible. The `llvm_verify` and `jvm_verify` functions return values of type `CrucibleMethodSpec` and `JVMMethodSpec`, respectively. These values are opaque objects that internally contain both the information -provided in the associated `JVMSetup` or `CrucibleSetup` blocks and +provided in the associated `JVMSetup` or `LLVMSetup` blocks and the results of the verification process. Any of these `MethodSpec` objects can be passed in via the third @@ -2128,7 +2128,7 @@ point to allocated memory before they are called. The `llvm_alloc` command allows you to specify that a function expects a particular pointer to refer to an allocated region appropriate for a specific type. -* `llvm_alloc : LLVMType -> CrucibleSetup SetupValue` +* `llvm_alloc : LLVMType -> LLVMSetup SetupValue` This command returns a `SetupValue` consisting of a pointer to the allocated space, which can be used wherever a pointer-valued @@ -2151,7 +2151,7 @@ In LLVM, it's also possible to construct fresh pointers that do not point to allocated memory (which can be useful for functions that manipulate pointers but not the values they point to): -* `llvm_fresh_pointer : LLVMType -> CrucibleSetup SetupValue` +* `llvm_fresh_pointer : LLVMType -> LLVMSetup SetupValue` The NULL pointer is called `llvm_null` in LLVM and `jvm_null` in JVM: @@ -2161,7 +2161,7 @@ JVM: One final, slightly more obscure command is the following: -* `llvm_alloc_readonly : LLVMType -> CrucibleSetup SetupValue` +* `llvm_alloc_readonly : LLVMType -> LLVMSetup SetupValue` This works like `llvm_alloc` except that writes to the space allocated are forbidden. This can be useful for specifying that a @@ -2181,7 +2181,7 @@ appropriate. In most cases, however, it's more useful to state that a pointer points to some specific (usually symbolic) value, which you can do with the `llvm_points_to` command. -* `llvm_points_to : SetupValue -> SetupValue -> CrucibleSetup ()` +* `llvm_points_to : SetupValue -> SetupValue -> LLVMSetup ()` takes two `SetupValue` arguments, the first of which must be a pointer, and states that the memory specified by that pointer should contain the value given in the second argument (which may be any type of @@ -2196,7 +2196,7 @@ type as another through casts, it can be useful to specify that a pointer points to a value that does not agree with its static type. * `llvm_points_to_untyped : SetupValue -> SetupValue -> -CrucibleSetup ()` works like `llvm_points_to` but omits type +LLVMSetup ()` works like `llvm_points_to` but omits type checking. Rather than omitting type checking across the board, we introduced this additional function to make it clear when a type reinterpretation is intentional. As an alternative, one @@ -2231,7 +2231,7 @@ of `llvm_fresh_var` and `llvm_elem` or `llvm_field` commands. However, the following function can simplify the common case where you want every element or field to have a fresh value. -* `llvm_fresh_expanded_val : LLVMType -> CrucibleSetup SetupValue` +* `llvm_fresh_expanded_val : LLVMType -> LLVMSetup SetupValue` The `llvm_struct_value` function normally creates a `struct` whose layout obeys the alignment rules of the platform specified in the LLVM file @@ -2300,7 +2300,7 @@ special care is required to write SAW specifications involving bitfields. For this reason, there is a dedicated `llvm_points_to_bitfield` function for this purpose: -* `llvm_points_to_bitfield : SetupValue -> String -> SetupValue -> CrucibleSetup ()` +* `llvm_points_to_bitfield : SetupValue -> String -> SetupValue -> LLVMSetup ()` The type of `llvm_points_to_bitfield` is similar that of `llvm_points_to`, except that it takes the name of a field within a bitfield as an additional @@ -2356,7 +2356,7 @@ them. Mutable global variables that are accessed in a function must first be allocated by calling `llvm_alloc_global` on the name of the global. -* `llvm_alloc_global : String -> CrucibleSetup ()` +* `llvm_alloc_global : String -> LLVMSetup ()` This ensures that all global variables that might influence the function are accounted for explicitly in the specification: if `llvm_alloc_global` is @@ -2461,17 +2461,21 @@ rise to specific final conditions. For these cases, you can specify an arbitrary predicate as a precondition or post-condition, using any values in scope at the time. -* `llvm_precond : Term -> CrucibleSetup ()` -* `llvm_postcond : Term -> CrucibleSetup ()` +* `llvm_precond : Term -> LLVMSetup ()` +* `llvm_postcond : Term -> LLVMSetup ()` +* `llvm_assert : Term -> LLVMSetup ()` * `jvm_precond : Term -> JVMSetup ()` * `jvm_postcond : Term -> JVMSetup ()` +* `jvm_assert : Term -> JVMSetup ()` -These two commands take `Term` arguments, and therefore cannot describe -the values of pointers. The `llvm_equal` command states that two -`SetupValue`s should be equal, and can be used in either the initial or -the final state. +These commands take `Term` arguments, and therefore cannot describe +the values of pointers. The "assert" variants will work in either pre- +or post-conditions, and are useful when defining helper functions +that, e.g., state datastructure invariants that make sense in both +phases. The `llvm_equal` command states that two `SetupValue`s should +be equal, and can be used in either the initial or the final state. -* `llvm_equal : SetupValue -> SetupValue -> CrucibleSetup ()` +* `llvm_equal : SetupValue -> SetupValue -> LLVMSetup ()` The use of `llvm_equal` can also sometimes lead to more efficient symbolic execution when the predicate of interest is an equality. @@ -2487,7 +2491,7 @@ simulation of the function. To skip simulation altogether, one can use: ~~~ llvm_unsafe_assume_spec : - LLVMModule -> String -> CrucibleSetup () -> TopLevel CrucibleMethodSpec + LLVMModule -> String -> LLVMSetup () -> TopLevel CrucibleMethodSpec ~~~ Or, in the experimental JVM implementation: @@ -2634,7 +2638,7 @@ Ghost state variables do not initially have any particluar type, and can store data of any type. Given an existing ghost variable the following function can be used to specify its value: -* `llvm_ghost_value : Ghost -> Term -> CrucibleSetup ()` +* `llvm_ghost_value : Ghost -> Term -> LLVMSetup ()` Currently, this function can only be used for LLVM verification, though that will likely be generalized in the future. It can be used in either @@ -2679,7 +2683,7 @@ above. #### Utility Functions We first define the function -`alloc_init : LLVMType -> Term -> CrucibleSetup SetupValue`. +`alloc_init : LLVMType -> Term -> LLVMSetup SetupValue`. `alloc_init ty v` returns a `SetupValue` consisting of a pointer to memory allocated and initialized to a value `v` of type `ty`. `alloc_init_readonly` @@ -2702,7 +2706,7 @@ let alloc_init_readonly ty v = do { ~~~~ We now define -`ptr_to_fresh : String -> LLVMType -> CrucibleSetup (Term, SetupValue)`. +`ptr_to_fresh : String -> LLVMType -> LLVMSetup (Term, SetupValue)`. `ptr_to_fresh n ty` returns a pair `(x, p)` consisting of a fresh symbolic variable `x` of type `ty` and a pointer `p` to it. `n` specifies the @@ -2724,7 +2728,7 @@ let ptr_to_fresh_readonly n ty = do { ~~~~ Finally, we define -`oneptr_update_func : String -> LLVMType -> Term -> CrucibleSetup ()`. +`oneptr_update_func : String -> LLVMType -> Term -> LLVMSetup ()`. `oneptr_update_func n ty f` specifies the behavior of a function that takes a single pointer (with a printable name given by `n`) to memory containing a @@ -2753,7 +2757,7 @@ Cryptol implementation and it is asserted that the pointers do in fact point to these expected values. ~~~~ -let quarterround_setup : CrucibleSetup () = do { +let quarterround_setup : LLVMSetup () = do { (y0, p0) <- ptr_to_fresh "y0" (llvm_int 32); (y1, p1) <- ptr_to_fresh "y1" (llvm_int 32); (y2, p2) <- ptr_to_fresh "y2" (llvm_int 32); diff --git a/doc/manual/manual.pdf b/doc/manual/manual.pdf index 5d121e0738788f15de32538da0ccf7a4682d7f9b..985611f3ea16e537812bb7ec47f11b9e3ca2c682 100644 GIT binary patch delta 70104 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∨cyNbA$5*vLq5c>GVnhI7fS$+T^>ma6zjG(X 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 B$M*mL delta 70167 zcmV(;K-<5}g&nJg9kAjj0Wy~XIsz#{TU&F}N)mq0ukfQ>6$@!*bbExeAqxcs2WQ~{ z&VwRPVil5QbVn8f|E@sDgn`xcqk_Uud|>i z!vO)QlVmE>fB$aqbY&^u>(%1c22j7=2Kc@7PkO&cI?t;v7Xcyv<_Zm~Zm&vx4Qq`L z&gajB|G!4U#@a$GYz=NKvjeyPE-~;C93DrkKn8pqal$*{reD&J4G*^${!d|7ci%#g ziJwO4_N4(Z18rXL5hzHdZ}6%3xQC~_7?;_1BqTaG<`E0=c{@O>`tJ6#NI zSCWM%SiyQ+wt0hQM4VMWfq-h@K?TL6twaAWqu0Y55weZjth_5(fw8 zr%NH)aerkz2}3`NBC+lNCg7K{|NG{OL+{%@e{0}pslCh``mqWpB98qi2`6W@y?!Rr z2rm@(xYMquBJ=W=b2m4MG4){z{~G5OF*aCI*?5y!@=aosYg^{@=-ET4D0zW=!j}TJ zvAGFqoCM6Nb8yn(Us>c_**bH&;y&@RsOi)$p=j#$K-Lc$;oV~A8n=j)AA~8bnisGn zf16lZTHEWVox#H1tZwx&vmOmD%(-^2V|RMn*M#XE@0ebUFrc?9H%x>)zTDdOrRJO3 z`MJq5*9b6;5csqZn7gwU8TnzF(OL}X0mueC+6>G*yS8AdT1`$?1;gHOu?3ovX3_~` ziWvq0bDi8IyWzak{dSRK@gVoQE&E>cf0*TpGT8|~rqrufW`gfuQxb`iBN7Wr!y;P^ zsA_JD$d7*!P2u%PW3f6}Vq0aHnEP))+3Oxq0r4XWde8yNmz?rW11fv_q* z(CK�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

TuN7CwnHgf~sH4{pxI+hARsb?gLc8%@ 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 ra%bJ=k^E=G599TneZSr1S^&mBAlTp8g+o Date: Fri, 20 May 2022 12:02:17 -0700 Subject: [PATCH 10/10] Update saw-remote-api to fix build failures. --- saw-remote-api/src/SAWServer.hs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/saw-remote-api/src/SAWServer.hs b/saw-remote-api/src/SAWServer.hs index b6ac03c7f6..30beb3d297 100644 --- a/saw-remote-api/src/SAWServer.hs +++ b/saw-remote-api/src/SAWServer.hs @@ -47,7 +47,7 @@ import Verifier.SAW.TypedTerm (TypedTerm, CryptolModule) import SAWScript.Crucible.LLVM.Builtins (CheckPointsToType) import SAWScript.Crucible.LLVM.X86 (defaultStackBaseAlign) -import qualified SAWScript.Crucible.Common as CC (defaultSAWCoreBackendTimeout) +import qualified SAWScript.Crucible.Common as CC (defaultSAWCoreBackendTimeout, PathSatSolver(..)) import qualified SAWScript.Crucible.Common.MethodSpec as CMS (ProvedSpec, GhostGlobal) import qualified SAWScript.Crucible.LLVM.MethodSpecIR as CMS (SomeLLVM, LLVMModule) import SAWScript.Options (Options(..), processEnv, defaultOptions) @@ -239,6 +239,8 @@ initialState readFileFn = , rwPreservedRegs = [] , rwAllocSymInitCheck = True , rwCrucibleTimeout = CC.defaultSAWCoreBackendTimeout + , rwPathSatSolver = CC.PathSat_Z3 + , rwSkipSafetyProofs = False } return (SAWState emptyEnv bic [] ro rw M.empty)