Example #1
0
 private static void BuildAssignment(Sink sink, Bpl.StmtListBuilder stmtBuilder, List <Bpl.Variable> lvars, List <Bpl.Variable> rvars)
 {
     for (int i = 0; i < lvars.Count; i++)
     {
         Bpl.Variable       lvar  = lvars[i];
         Bpl.Type           ltype = lvar.TypedIdent.Type;
         Bpl.Variable       rvar  = rvars[i];
         Bpl.Type           rtype = rvar.TypedIdent.Type;
         Bpl.IdentifierExpr lexpr = Bpl.Expr.Ident(lvar);
         Bpl.Expr           rexpr = Bpl.Expr.Ident(rvar);
         if (rtype == ltype)
         {
             // do nothing
         }
         else if (ltype == sink.Heap.UnionType)
         {
             rexpr = sink.Heap.ToUnion(Bpl.Token.NoToken, rtype, rexpr, false, stmtBuilder);
         }
         else if (rtype == sink.Heap.UnionType)
         {
             rexpr = sink.Heap.FromUnion(Bpl.Token.NoToken, ltype, rexpr, false);
         }
         else
         {
             System.Diagnostics.Debug.Assert(false);
         }
         stmtBuilder.Add(TranslationHelper.BuildAssignCmd(lexpr, rexpr));
     }
 }
Example #2
0
 public bool isOutParam(bpl.Variable vbl)
 {
     if (vbl == null)
     {
         return(false);
     }
     return(hasAttrKey(vbl.Attributes, outParamAttr));
 }
Example #3
0
 public bool isAllTypes(bpl.Variable vbl)
 {
     if (vbl == null)
     {
         return(false);
     }
     return(isTemplate(vbl) && !isGlobal(vbl) && !isInParam(vbl) && !isOutParam(vbl) && !isLocal(vbl));
 }
Example #4
0
 public bool isNonTemplate(bpl.Variable vbl)
 {
     if (vbl == null)
     {
         return(false);
     }
     return(!hasAttrKey(vbl.Attributes, templateAttr));
 }
Example #5
0
 public bool isLocal(bpl.Variable vbl)
 {
     if (vbl == null)
     {
         return(false);
     }
     return(hasAttrKey(vbl.Attributes, localAttr));
 }
Example #6
0
 public BplMatch(string v2Prefix)
 {
     _v2Prefix = v2Prefix;
     _renamer = new Utils.VarRenamer(v2Prefix + ".", new string[] { });
     _eqVarsCounter = 0;
     _numOverallAsserts = 0;
     _havocVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, HavocVarName, BType.Bool));
 }
Example #7
0
    private Tuple<Variable, Variable> createNewExplainConstants(Variable v)
    {
        Contract.Assert(impl != null);
        Contract.Assert(CommandLineOptions.Clo.ExplainHoudini);
        Variable v1 = new Constant(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("{0}_{1}_{2}", v.Name, impl.Name, "pos"), Microsoft.Boogie.BasicType.Bool));
        Variable v2 = new Constant(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("{0}_{1}_{2}", v.Name, impl.Name, "neg"), Microsoft.Boogie.BasicType.Bool));

        return Tuple.Create(v1, v2);
    }
Example #8
0
 private void addPhoneTopLevelDeclarations()
 {
     if (PhoneCodeHelper.instance().PhoneNavigationToggled)
     {
         Bpl.Variable continueOnPageVar = sink.FindOrCreateGlobalVariable(PhoneCodeHelper.BOOGIE_CONTINUE_ON_PAGE_VARIABLE, Bpl.Type.Bool);
         sink.TranslatedProgram.AddTopLevelDeclaration(continueOnPageVar);
         Bpl.Variable navigationCheckVar = sink.FindOrCreateGlobalVariable(PhoneCodeHelper.BOOGIE_NAVIGATION_CHECK_VARIABLE, Bpl.Type.Bool);
         sink.TranslatedProgram.AddTopLevelDeclaration(navigationCheckVar);
     }
 }
Example #9
0
        public override void TraverseChildren(IFieldDefinition fieldDefinition)
        {
            Bpl.Variable fieldVar = this.sink.FindOrCreateFieldVariable(fieldDefinition);

            // if tracked by the phone plugin, we need to find out the bpl assigned name for future use
            if (PhoneCodeHelper.instance().PhonePlugin != null)
            {
                trackControlVariableName(fieldDefinition, fieldVar);
                trackNavigationVariableName(fieldDefinition, fieldVar);
            }
        }
Example #10
0
        public bpl.Declaration getExistConstDeclaration(bpl.Variable vbl)
        {
            var res       = new bpl.Constant(bpl.Token.NoToken, new bpl.TypedIdent(bpl.Token.NoToken, vbl.Name, vbl.TypedIdent.Type), false);
            var paramList = new List <object>();

            paramList.Add(new bpl.LiteralExpr(bpl.Token.NoToken, true));
            var attr = new bpl.QKeyValue(bpl.Token.NoToken, existsConstAttr, paramList, null);

            attr.Next      = res.Attributes;
            res.Attributes = attr;
            return(res);
        }
        public Bpl.Variable getBoogieVariableForName(string varName)
        {
            Bpl.Variable boogieVar = null;
            try {
                boogieVar = boogieObjects[varName] as Bpl.Variable;
            } catch (KeyNotFoundException) {
            }

            if (boogieVar == null)
            {
                throw new ArgumentException("The boogie variable " + varName + " is not defined.");
            }

            return(boogieVar);
        }
Example #12
0
 private static void GenerateInAndOutExprs(Bpl.Expr e, List <Bpl.Variable> invars, List <Bpl.Variable> outvars, out List <Bpl.Expr> inExprs, out List <Bpl.IdentifierExpr> outExprs)
 {
     inExprs = new List <Bpl.Expr>();
     inExprs.Add(e);
     for (int i = 1; i < invars.Count; i++)
     {
         Bpl.Variable f = invars[i];
         inExprs.Add(Bpl.Expr.Ident(f));
     }
     outExprs = new List <Bpl.IdentifierExpr>();
     foreach (Bpl.Formal f in outvars)
     {
         outExprs.Add(Bpl.Expr.Ident(f));
     }
 }
    public MethodParameter(IParameterDefinition parameterDefinition, Bpl.Type ptype) {
      this.underlyingParameter = parameterDefinition;

      var parameterToken = parameterDefinition.Token();
      var typeToken = parameterDefinition.Type.Token();
      var parameterName = TranslationHelper.TurnStringIntoValidIdentifier(parameterDefinition.Name.Value);
      if (String.IsNullOrWhiteSpace(parameterName)) parameterName = "P" + parameterDefinition.Index.ToString();

      this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
      if (parameterDefinition.IsByReference) {
        this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
      } else {
        this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
      }
    }
 private Function TriggerFunction(Variable v)
 {
     PopulateExistsVars(v);
     if (firstExistsVars.Contains(v))
     {
         return first.TriggerFunction(v);
     }
     else if (secondExistsVars.Contains(v))
     {
         return second.TriggerFunction(v);
     }
     else
     {
         Debug.Assert(false);
         return null;
     }
 }
Example #15
0
        ////////////////////////////////////////////////////////////////////////////////////
        //TODO:Check if we get functions here
        private Term makeExpression(QuantifierExpr qe, bool old)
        {
            Term e = null;

            {
                List <Logic.Variable> quantifiedVariables = new List <Logic.Variable>();
                foreach (Microsoft.Boogie.Variable bv in qe.Dummies)
                {
                    quantifiedVariables.Add(new Logic.Basic.Variable(bv.TypedIdent.Name));
                }
                foreach (var v in quantifiedVariables)
                {
                    boundVariables.Add(v.name, v);
                }
                e = makeExpression(qe.Body, old);
                foreach (var v in quantifiedVariables)
                {
                    boundVariables.Remove(v.name);
                }
            }


            {
                Logic.Quantifier q = makeQuantifier(qe.Kind);
                for (int i = qe.Dummies.Length - 1; i >= 0; i--)
                {
                    Microsoft.Boogie.Variable v = qe.Dummies[i];
                    Logic.Sort     ls           = new Logic.Boogie.BoogieSort(v.TypedIdent.Type);
                    Logic.Variable lv           = new Logic.Boogie.BoogieVariable(v);
                    e = new Boogie.QuantifiedExpression(qe, q, lv, ls, e);
                }
            }
            {
                Logic.TypeQuantifier tq = makeTypeQuantifier(qe.Kind);
                for (int i = qe.TypeParameters.Length - 1; i >= 0; i--)
                {
                    Microsoft.Boogie.TypeVariable btv = qe.TypeParameters[i];
                    Logic.TypeVariable            tv  = new Logic.Boogie.TypeVariable(btv);
                    e = new Boogie.QuantifiedTypeExpression(qe, tq, tv, e);
                }
            }
            return(e);
        }
Example #16
0
    public MethodParameter(IParameterDefinition parameterDefinition) {

      this.underlyingParameter = parameterDefinition;

      Bpl.Type ptype = Bpl.Type.Int;

      var parameterToken = parameterDefinition.Token();
      var typeToken = parameterDefinition.Type.Token();
      var parameterName = parameterDefinition.Name.Value;

      if (!parameterDefinition.IsOut) {
        this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
      }
      if (parameterDefinition.IsByReference || parameterDefinition.IsOut) {
        this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
      } else {
        this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
      }
      
    }
        public MethodParameter(IParameterDefinition parameterDefinition, Bpl.Type ptype)
        {
            this.underlyingParameter = parameterDefinition;

            var parameterToken = parameterDefinition.Token();
            var typeToken      = parameterDefinition.Type.Token();
            var parameterName  = TranslationHelper.TurnStringIntoValidIdentifier(parameterDefinition.Name.Value);

            if (String.IsNullOrWhiteSpace(parameterName))
            {
                parameterName = "P" + parameterDefinition.Index.ToString();
            }

            this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
            if (parameterDefinition.IsByReference)
            {
                this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
            }
            else
            {
                this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
            }
        }
Example #18
0
 public override Variable VisitVariable(Variable node)
 {
     CivlAttributes.RemoveLayerAttribute(node);
     return base.VisitVariable(node);
 }
Example #19
0
 private int FindLocalVariableLayer(Declaration decl, Variable v, int enclosingProcLayerNum)
 {
     var layers = FindLayers(v.Attributes);
     if (layers.Count == 0) return int.MinValue;
     if (layers.Count > 1)
     {
         Error(decl, "Incorrect number of layers");
         return int.MinValue;
     }
     if (layers[0] > enclosingProcLayerNum)
     {
         Error(decl, "Layer of local variable cannot be greater than the creation layer of enclosing procedure");
         return int.MinValue;
     }
     return layers[0];
 }
Example #20
0
 //Other special variables
 public bool isAtomicBlockVar(bpl.Variable variable)
 {
     return(variable != null && variable is bpl.GlobalVariable && variable.Name == atomicBlockVar);
 }
        public Bpl.Procedure addHandlerStubCaller(Sink sink, IMethodDefinition def)
        {
            MethodBody       callerBody = new MethodBody();
            MethodDefinition callerDef  = new MethodDefinition()
            {
                InternFactory            = (def as MethodDefinition).InternFactory,
                ContainingTypeDefinition = def.ContainingTypeDefinition,
                IsStatic = true,
                Name     = sink.host.NameTable.GetNameFor("BOOGIE_STUB_CALLER_" + def.Name.Value),
                Type     = sink.host.PlatformType.SystemVoid,
                Body     = callerBody,
            };

            callerBody.MethodDefinition = callerDef;
            Sink.ProcedureInfo procInfo   = sink.FindOrCreateProcedure(def);
            Sink.ProcedureInfo callerInfo = sink.FindOrCreateProcedure(callerDef);

            Bpl.LocalVariable[]  localVars = new Bpl.LocalVariable[procInfo.Decl.InParams.Count];
            Bpl.IdentifierExpr[] varExpr   = new Bpl.IdentifierExpr[procInfo.Decl.InParams.Count];
            for (int i = 0; i < procInfo.Decl.InParams.Count; i++)
            {
                Bpl.LocalVariable loc = new Bpl.LocalVariable(Bpl.Token.NoToken,
                                                              new Bpl.TypedIdent(Bpl.Token.NoToken, TranslationHelper.GenerateTempVarName(),
                                                                                 procInfo.Decl.InParams[i].TypedIdent.Type));
                localVars[i] = loc;
                varExpr[i]   = new Bpl.IdentifierExpr(Bpl.Token.NoToken, loc);
            }

            Bpl.StmtListBuilder builder = new Bpl.StmtListBuilder();
            builder.Add(getResetNavigationCheck(sink));

            string pageXaml = PhoneCodeHelper.instance().PhonePlugin.getXAMLForPage(def.ContainingTypeDefinition.ToString());

            Bpl.Variable boogieCurrentURI = sink.FindOrCreateFieldVariable(PhoneCodeHelper.CurrentURIFieldDefinition);
            Bpl.Constant boogieXamlConstant;
            if (pageXaml != null)
            {
                boogieXamlConstant = sink.FindOrCreateConstant(pageXaml);
            }
            else
            {
                boogieXamlConstant = null;
            }
            // NAVIGATION TODO: For now just assume we are in this page to be able to call the handler, this is NOT true for any handler
            // NAVIGATION TODO: ie, a network event handler
            if (boogieXamlConstant != null)
            {
                Bpl.AssumeCmd assumeCurrentPage =
                    new Bpl.AssumeCmd(Bpl.Token.NoToken,
                                      Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, new Bpl.IdentifierExpr(Bpl.Token.NoToken, boogieCurrentURI),
                                                      new Bpl.IdentifierExpr(Bpl.Token.NoToken, boogieXamlConstant)));
                builder.Add(assumeCurrentPage);
            }

            // NAVIGATION TODO: have to do the pair generation all in one go instead of having different files that need to be sed'ed
            boogieXamlConstant = sink.FindOrCreateConstant(BOOGIE_STARTING_URI_PLACEHOLDER);
            Bpl.AssumeCmd assumeStartPage = new Bpl.AssumeCmd(Bpl.Token.NoToken,
                                                              Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, new Bpl.IdentifierExpr(Bpl.Token.NoToken, boogieCurrentURI),
                                                                              new Bpl.IdentifierExpr(Bpl.Token.NoToken, boogieXamlConstant)));
            builder.Add(assumeStartPage);
            builder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, procInfo.Decl.Name, new List <Bpl.Expr>(varExpr), new List <Bpl.IdentifierExpr>()));
            boogieXamlConstant = sink.FindOrCreateConstant(BOOGIE_ENDING_URI_PLACEHOLDER);
            Bpl.AssertCmd assertEndPage = new Bpl.AssertCmd(Bpl.Token.NoToken,
                                                            Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Neq, new Bpl.IdentifierExpr(Bpl.Token.NoToken, boogieCurrentURI),
                                                                            new Bpl.IdentifierExpr(Bpl.Token.NoToken, boogieXamlConstant)));

            Bpl.Expr            guard       = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateGlobalVariable(PhoneCodeHelper.BOOGIE_NAVIGATION_CHECK_VARIABLE, Bpl.Type.Bool));
            Bpl.StmtListBuilder thenBuilder = new Bpl.StmtListBuilder();
            thenBuilder.Add(assertEndPage);
            Bpl.IfCmd ifNavigated = new Bpl.IfCmd(Bpl.Token.NoToken, guard, thenBuilder.Collect(Bpl.Token.NoToken), null, new Bpl.StmtListBuilder().Collect(Bpl.Token.NoToken));

            builder.Add(ifNavigated);
            Bpl.Implementation impl =
                new Bpl.Implementation(Bpl.Token.NoToken, callerInfo.Decl.Name, new List <Bpl.TypeVariable>(), new List <Bpl.Variable>(),
                                       new List <Bpl.Variable>(), new List <Bpl.Variable>(localVars), builder.Collect(Bpl.Token.NoToken), null, new Bpl.Errors());

            sink.TranslatedProgram.AddTopLevelDeclaration(impl);
            return(impl.Proc);
        }
Example #22
0
 public override Variable VisitVariable(Variable node)
 {
     string domainName = FindDomainName(node);
     if (domainName != null)
     {
         if (!domainNameToCollectors.ContainsKey(domainName))
         {
             domainNameToCollectors[domainName] = new Dictionary<Type,Function>();
         }
         LinearKind kind = FindLinearKind(node);
         if (kind != LinearKind.LINEAR)
         {
             if (node is GlobalVariable || node is LocalVariable || (node is Formal && !(node as Formal).InComing))
             {
                 Error(node, "Variable must be declared linear (as opposed to linear_in or linear_out)");
             }
         }
     }
     return base.VisitVariable(node);
 }
Example #23
0
 private Expr SubsetExprs(LinearDomain domain, HashSet<Variable> scope, Variable partition, int count, Expr expr)
 {
     foreach (Variable v in scope)
     {
         if (!domain.collectors.ContainsKey(v.TypedIdent.Type)) continue;
         Expr ie = new NAryExpr(Token.NoToken, new FunctionCall(domain.collectors[v.TypedIdent.Type]), new List<Expr> { Expr.Ident(v) });
         expr = Expr.And(SubsetExpr(domain, ie, partition, count), expr);
         count++;
     }
     expr = new ExistsExpr(Token.NoToken, new List<Variable> { partition }, expr);
     expr.Resolve(new ResolutionContext(null));
     expr.Typecheck(new TypecheckingContext(null));
     return expr;
 }
Example #24
0
 public virtual Variable VisitVariable(Variable node) {
   Contract.Requires(node != null);
   Contract.Ensures(Contract.Result<Variable>() != null);
   node.TypedIdent = this.VisitTypedIdent(node.TypedIdent);
   return node;
 }
Example #25
0
 public string FindDomainName(Variable v)
 {
     if (globalVarToDomainName.ContainsKey(v))
         return globalVarToDomainName[v];
     if (inParamToLinearQualifier.ContainsKey(v))
         return inParamToLinearQualifier[v].domainName;
     if (outParamToDomainName.ContainsKey(v))
         return outParamToDomainName[v];
     string domainName = QKeyValue.FindStringAttribute(v.Attributes, "linear");
     if (domainName != null)
         return domainName;
     domainName = QKeyValue.FindStringAttribute(v.Attributes, "linear_in");
     if (domainName != null)
         return domainName;
     return QKeyValue.FindStringAttribute(v.Attributes, "linear_out");
 }
Example #26
0
        private static void trackControlVariableName(IFieldDefinition fieldDefinition, Bpl.Variable fieldVar)
        {
            INamespaceTypeReference namedContainerRef = fieldDefinition.ContainingType as INamespaceTypeReference;

            if (namedContainerRef != null)
            {
                string containerName = namedContainerRef.ContainingUnitNamespace.Unit.Name.Value + "." + namedContainerRef.Name.Value;
                IEnumerable <ControlInfoStructure> controls = PhoneCodeHelper.instance().PhonePlugin.getControlsForPage(containerName);
                if (controls != null)
                {
                    ControlInfoStructure ctrlInfo = controls.FirstOrDefault(ctrl => ctrl.Name == fieldDefinition.Name.Value);
                    if (ctrlInfo != null)
                    {
                        ctrlInfo.BplName = fieldVar.Name;
                    }
                }
            }
        }
Example #27
0
 public Function TriggerFunction(Variable v)
 {
     if (!triggerFuns.ContainsKey(v))
     {
         List<Variable> args = new List<Variable>();
         args.Add(new Formal(v.tok, new TypedIdent(v.tok, "v", v.TypedIdent.Type), true));
         Variable result = new Formal(v.tok, new TypedIdent(v.tok, "r", Type.Bool), false);
         triggerFuns[v] = new Function(v.tok, string.Format("Trigger_{0}_{1}", proc.Name, v.Name), args, result);
     }
     return triggerFuns[v];
 }
Example #28
0
 private static void trackNavigationVariableName(IFieldDefinition fieldDefinition, Bpl.Variable fieldVar)
 {
     if (fieldDefinition.Name.Value.Equals(PhoneCodeHelper.IL_CURRENT_NAVIGATION_URI_VARIABLE))
     {
         PhoneCodeHelper.instance().setBoogieNavigationVariable(fieldVar.Name);
     }
 }
Example #29
0
        private static void CreateDispatchMethod(Sink sink, ITypeDefinition type, HashSet <IMethodDefinition> delegates)
        {
            Contract.Assert(type.IsDelegate);
            IMethodDefinition invokeMethod = null;

            foreach (IMethodDefinition m in type.Methods)
            {
                if (m.Name.Value == "Invoke")
                {
                    invokeMethod = m;
                    break;
                }
            }

            try {
                IMethodDefinition  unspecializedInvokeMethod = Sink.Unspecialize(invokeMethod).ResolvedMethod;
                Sink.ProcedureInfo invokeProcedureInfo       = sink.FindOrCreateProcedure(unspecializedInvokeMethod);
                Bpl.Procedure      invokeProcedure           = (Bpl.Procedure)invokeProcedureInfo.Decl;
                invokeProcedure.AddAttribute("inline", Bpl.Expr.Literal(1));
                Bpl.Formal delegateVariable = invokeProcedureInfo.ThisVariable;
                Bpl.IToken token            = invokeMethod.Token();

                List <Bpl.Variable> dispatchProcInExprs = new List <Bpl.Variable>();
                for (int i = 1; i < invokeProcedure.InParams.Count; i++)
                {
                    Bpl.Variable v = invokeProcedure.InParams[i];
                    dispatchProcInExprs.Add(v);
                }
                List <Bpl.Variable> dispatchProcOutExprs = new List <Bpl.Variable>();
                foreach (Bpl.Variable v in invokeProcedure.OutParams)
                {
                    dispatchProcOutExprs.Add(v);
                }

                List <Bpl.Variable> localVariables = new List <Bpl.Variable>();
                Bpl.StmtListBuilder stmtBuilder    = new Bpl.StmtListBuilder();
                int localCounter = 0;
                foreach (IMethodDefinition defn in delegates)
                {
                    Bpl.Constant       c = sink.FindOrCreateDelegateMethodConstant(defn);
                    Sink.ProcedureInfo delegateProcedureInfo = sink.FindOrCreateProcedure(defn);
                    Bpl.Procedure      delegateProcedure     = (Bpl.Procedure)delegateProcedureInfo.Decl;
                    Bpl.Formal         thisVariable          = delegateProcedureInfo.ThisVariable;
                    int numArguments = defn.ParameterCount;

                    List <Bpl.Variable> tempInputs  = new List <Bpl.Variable>();
                    List <Bpl.Variable> tempOutputs = new List <Bpl.Variable>();

                    for (int i = 0; i < defn.ParameterCount; i++)
                    {
                        Bpl.Variable      v             = delegateProcedure.InParams[(thisVariable == null ? 0 : 1) + i];
                        Bpl.LocalVariable localVariable = new Bpl.LocalVariable(Bpl.Token.NoToken,
                                                                                new Bpl.TypedIdent(Bpl.Token.NoToken, "local" + localCounter++, v.TypedIdent.Type));
                        localVariables.Add(localVariable);
                        tempInputs.Add(localVariable);
                    }

                    for (int i = 0; i < delegateProcedure.OutParams.Count; i++)
                    {
                        Bpl.Variable      v             = delegateProcedure.OutParams[i];
                        Bpl.LocalVariable localVariable = new Bpl.LocalVariable(Bpl.Token.NoToken,
                                                                                new Bpl.TypedIdent(Bpl.Token.NoToken, "local" + localCounter++, v.TypedIdent.Type));
                        localVariables.Add(localVariable);
                        tempOutputs.Add(localVariable);
                    }

                    List <Bpl.Expr>           ins  = new List <Bpl.Expr>();
                    List <Bpl.IdentifierExpr> outs = new List <Bpl.IdentifierExpr>();
                    if (!defn.IsStatic)
                    {
                        ins.Add(sink.ReadReceiver(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)));
                    }
                    for (int i = 0; i < tempInputs.Count; i++)
                    {
                        ins.Add(Bpl.Expr.Ident(tempInputs[i]));
                    }
                    if (defn.IsGeneric)
                    {
                        for (int i = 0; i < defn.GenericParameterCount; i++)
                        {
                            ins.Add(new Bpl.NAryExpr(Bpl.Token.NoToken,
                                                     new Bpl.FunctionCall(sink.FindOrCreateTypeParameterFunction(i)),
                                                     new List <Bpl.Expr>(new Bpl.Expr[] { sink.ReadTypeParameters(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)) })));
                        }
                    }
                    if (defn.IsStatic)
                    {
                        int numTypeParameters = Sink.ConsolidatedGenericParameterCount(defn.ContainingType);
                        for (int i = 0; i < numTypeParameters; i++)
                        {
                            ins.Add(new Bpl.NAryExpr(Bpl.Token.NoToken,
                                                     new Bpl.FunctionCall(sink.FindOrCreateTypeParameterFunction(i)),
                                                     new List <Bpl.Expr>(new Bpl.Expr[] { sink.ReadTypeParameters(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)) })));
                        }
                    }
                    for (int i = 0; i < tempOutputs.Count; i++)
                    {
                        outs.Add(Bpl.Expr.Ident(tempOutputs[i]));
                    }

                    Bpl.Expr            bexpr         = sink.ReadMethod(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable));
                    Bpl.StmtListBuilder ifStmtBuilder = new Bpl.StmtListBuilder();
                    System.Diagnostics.Debug.Assert(tempInputs.Count == dispatchProcInExprs.Count);
                    if (tempInputs.Count > 0)
                    {
                        BuildAssignment(sink, ifStmtBuilder, tempInputs, dispatchProcInExprs);
                    }
                    ifStmtBuilder.Add(EmitDummySourceContext());
                    ifStmtBuilder.Add(new Bpl.CallCmd(token, delegateProcedure.Name, ins, outs));
                    System.Diagnostics.Debug.Assert(tempOutputs.Count == dispatchProcOutExprs.Count);
                    if (tempOutputs.Count > 0)
                    {
                        BuildAssignment(sink, ifStmtBuilder, dispatchProcOutExprs, tempOutputs);
                    }
                    stmtBuilder.Add(new Bpl.IfCmd(bexpr.tok, bexpr, ifStmtBuilder.Collect(bexpr.tok), null, null));
                }

                Bpl.Implementation dispatchImpl =
                    new Bpl.Implementation(token,
                                           invokeProcedure.Name,
                                           new List <Bpl.TypeVariable>(),
                                           invokeProcedure.InParams,
                                           invokeProcedure.OutParams,
                                           localVariables,
                                           stmtBuilder.Collect(token)
                                           );
                dispatchImpl.Proc = invokeProcedure;
                dispatchImpl.AddAttribute("inline", Bpl.Expr.Literal(1));
                sink.TranslatedProgram.AddTopLevelDeclaration(dispatchImpl);
            } catch (TranslationException te) {
                throw new NotImplementedException(te.ToString());
            } catch {
                throw;
            } finally {
                // Maybe this is a good place to add the procedure to the toplevel declarations
            }
        }
        public override void TraverseChildren(ITryCatchFinallyStatement tryCatchFinallyStatement)
        {
            if (this.sink.Options.modelExceptions == 0)
            {
                this.Traverse(tryCatchFinallyStatement.TryBody);
                if (tryCatchFinallyStatement.FinallyBody != null)
                {
                    this.Traverse(tryCatchFinallyStatement.FinallyBody);
                }
                return;
            }

            this.sink.nestedTryCatchFinallyStatements.Add(new Tuple <ITryCatchFinallyStatement, Sink.TryCatchFinallyContext>(tryCatchFinallyStatement, Sink.TryCatchFinallyContext.InTry));
            this.Traverse(tryCatchFinallyStatement.TryBody);
            StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.LabelVariable), Bpl.Expr.Literal(-1)));
            StmtBuilder.Add(new Bpl.GotoCmd(Bpl.Token.NoToken, new List <string>(new string[] { this.sink.FindOrCreateFinallyLabel(tryCatchFinallyStatement) })));
            this.sink.nestedTryCatchFinallyStatements.RemoveAt(this.sink.nestedTryCatchFinallyStatements.Count - 1);

            StmtBuilder.AddLabelCmd(this.sink.FindOrCreateCatchLabel(tryCatchFinallyStatement));
            StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.LocalExcVariable), Bpl.Expr.Ident(this.sink.Heap.ExceptionVariable)));
            StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.Heap.ExceptionVariable), Bpl.Expr.Ident(this.sink.Heap.NullRef)));
            List <Bpl.StmtList> catchStatements = new List <Bpl.StmtList>();
            List <Bpl.Expr>     typeReferences  = new List <Bpl.Expr>();

            this.sink.nestedTryCatchFinallyStatements.Add(new Tuple <ITryCatchFinallyStatement, Sink.TryCatchFinallyContext>(tryCatchFinallyStatement, Sink.TryCatchFinallyContext.InCatch));
            foreach (ICatchClause catchClause in tryCatchFinallyStatement.CatchClauses)
            {
                typeReferences.Insert(0, this.sink.FindOrCreateTypeReference(catchClause.ExceptionType, true));
                StatementTraverser catchTraverser = this.factory.MakeStatementTraverser(this.sink, this.PdbReader, this.contractContext);
                if (catchClause.ExceptionContainer != Dummy.LocalVariable)
                {
                    Bpl.Variable catchClauseVariable = this.sink.FindOrCreateLocalVariable(catchClause.ExceptionContainer);
                    catchTraverser.StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(catchClauseVariable), Bpl.Expr.Ident(this.sink.LocalExcVariable)));
                }
                catchTraverser.Traverse(catchClause.Body);
                catchTraverser.StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.LabelVariable), Bpl.Expr.Literal(-1)));
                catchTraverser.StmtBuilder.Add(new Bpl.GotoCmd(Bpl.Token.NoToken, new List <string>(new string[] { this.sink.FindOrCreateFinallyLabel(tryCatchFinallyStatement) })));
                catchStatements.Insert(0, catchTraverser.StmtBuilder.Collect(catchClause.Token()));
            }
            Bpl.IfCmd elseIfCmd        = new Bpl.IfCmd(Bpl.Token.NoToken, Bpl.Expr.Literal(false), TranslationHelper.BuildStmtList(new Bpl.ReturnCmd(Bpl.Token.NoToken)), null, null);
            Bpl.Expr  dynTypeOfOperand = this.sink.Heap.DynamicType(Bpl.Expr.Ident(this.sink.LocalExcVariable));
            for (int i = 0; i < catchStatements.Count; i++)
            {
                Bpl.Expr expr = new Bpl.NAryExpr(Bpl.Token.NoToken, new Bpl.FunctionCall(this.sink.Heap.Subtype), new List <Bpl.Expr>(new Bpl.Expr[] { dynTypeOfOperand, typeReferences[i] }));
                elseIfCmd = new Bpl.IfCmd(Bpl.Token.NoToken, expr, catchStatements[i], elseIfCmd, null);
            }
            this.StmtBuilder.Add(elseIfCmd);
            this.StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.Heap.ExceptionVariable), Bpl.Expr.Ident(this.sink.LocalExcVariable)));
            RaiseException();
            this.sink.nestedTryCatchFinallyStatements.RemoveAt(this.sink.nestedTryCatchFinallyStatements.Count - 1);

            this.StmtBuilder.AddLabelCmd(this.sink.FindOrCreateFinallyLabel(tryCatchFinallyStatement));
            if (tryCatchFinallyStatement.FinallyBody != null)
            {
                this.sink.nestedTryCatchFinallyStatements.Add(new Tuple <ITryCatchFinallyStatement, Sink.TryCatchFinallyContext>(tryCatchFinallyStatement, Sink.TryCatchFinallyContext.InFinally));
                Bpl.Variable savedExcVariable   = this.sink.CreateFreshLocal(this.sink.Heap.RefType);
                Bpl.Variable savedLabelVariable = this.sink.CreateFreshLocal(Bpl.Type.Int);
                StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(savedExcVariable), Bpl.Expr.Ident(this.sink.Heap.ExceptionVariable)));
                StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(savedLabelVariable), Bpl.Expr.Ident(this.sink.LabelVariable)));
                this.Traverse(tryCatchFinallyStatement.FinallyBody);
                StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.Heap.ExceptionVariable), Bpl.Expr.Ident(savedExcVariable)));
                StmtBuilder.Add(TranslationHelper.BuildAssignCmd(Bpl.Expr.Ident(this.sink.LabelVariable), Bpl.Expr.Ident(savedLabelVariable)));
                this.sink.nestedTryCatchFinallyStatements.RemoveAt(this.sink.nestedTryCatchFinallyStatements.Count - 1);
            }
            GenerateDispatchContinuation(tryCatchFinallyStatement);
            StmtBuilder.AddLabelCmd(this.sink.FindOrCreateContinuationLabel(tryCatchFinallyStatement));
            Bpl.Expr raiseExpr = Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Neq, Bpl.Expr.Ident(this.sink.Heap.ExceptionVariable), Bpl.Expr.Ident(this.sink.Heap.NullRef));
            RaiseException(raiseExpr);
        }
Example #31
0
 public string getShadowVarName(bpl.Variable glbl)
 {
     return(glbl.Name + shadowVarSuffix);
 }
Example #32
0
 public bool isTidOtherVar(bpl.Variable variable)
 {
     return(variable != null && variable is bpl.GlobalVariable && variable.Name == tidOther);
 }
Example #33
0
 public override Variable VisitVariable(Variable node)
 {
     Contract.Ensures(Contract.Result<Variable>() == node);
     this.VisitTypedIdent(node.TypedIdent);
     return node;
 }
Example #34
0
 public override Implementation VisitImplementation(Implementation node)
 {
     enclosingImpl = node;
     dummyLocalVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "og_dummy", Type.Bool));
     Implementation impl = base.VisitImplementation(node);
     implMap[impl] = node;
     impl.LocVars.Add(dummyLocalVar);
     impl.Name = impl.Proc.Name;
     return impl;
 }
Example #35
0
 public override Variable VisitVariable(Variable node)
 {
     node.Attributes = RemoveLinearAttribute(node.Attributes);
     return base.VisitVariable(node);
 }
Example #36
0
 public override Variable VisitVariable(Variable node) {
   //Contract.Requires(node != null);
   Contract.Ensures(Contract.Result<Variable>() != null);
   return node;
 }
Example #37
0
        public LinearKind FindLinearKind(Variable v)
        {
            if (globalVarToDomainName.ContainsKey(v))
                return LinearKind.LINEAR;
            if (inParamToLinearQualifier.ContainsKey(v))
                return inParamToLinearQualifier[v].kind;
            if (outParamToDomainName.ContainsKey(v))
                return LinearKind.LINEAR;

            if (QKeyValue.FindStringAttribute(v.Attributes, "linear") != null)
            {
                return LinearKind.LINEAR;
            }
            else if (QKeyValue.FindStringAttribute(v.Attributes, "linear_in") != null)
            { 
                return LinearKind.LINEAR_IN; 
            }
            else if (QKeyValue.FindStringAttribute(v.Attributes, "linear_out") != null)
            {
                return LinearKind.LINEAR_OUT;
            }
            else
            {
                Debug.Assert(false);
                return LinearKind.LINEAR;
            }
        }
Example #38
0
 public Expr/*?*/ Method(Variable v) {
   Contract.Requires(v != null);
   if(map.ContainsKey(v)) {
     return map[v];
   }
   Expr e;
   if (nameMap != null && proc != null && nameMap.TryGetValue(UniqueName(v, proc), out e))
   {
     return e;
   }
   return null;
 }
Example #39
0
 private Expr SubsetExpr(LinearDomain domain, Expr ie, Variable partition, int partitionCount)
 {
     Expr e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstInt), new List<Expr> { new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(partitionCount)) });
     e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapEqInt), new List<Expr> { Expr.Ident(partition), e });
     e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapImpBool), new List<Expr> { ie, e });
     e = Expr.Eq(e, new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List<Expr> { Expr.True }));
     return e;
 }
Example #40
0
 public bool InFrame(Variable v)
 {
     Contract.Requires(v != null);
       Contract.Requires(Frame != null);
       return Frame.Any(f => f.Decl == v);
 }
Example #41
0
 public Expr DisjointnessExpr(string domainName, Variable inputVar, HashSet<Variable> scope)
 {
     LinearDomain domain = linearDomains[domainName];
     BoundVariable partition = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("partition_{0}", domainName), new MapType(Token.NoToken, new List<TypeVariable>(), new List<Type> { domain.elementType }, Microsoft.Boogie.Type.Int)));
     return SubsetExprs(domain, scope, partition, 1, SubsetExpr(domain, Expr.Ident(inputVar), partition, 0));
 }
Example #42
0
 static Bpl.Expr BplForall(Bpl.Variable arg, Bpl.Trigger trg, Bpl.Expr body)
 {
     return(BplForall(Singleton(arg), trg, body));
 }
Example #43
0
  void AssignPredicates(Graph<Block> blockGraph,
                        DomRelation<Block> dom,
                        DomRelation<Block> pdom,
                        IEnumerable<Block> headerDominance,
                        IEnumerator<Tuple<Block, bool>> i,
                        Variable headPredicate,
                        ref int predCount) {
    var header = i.Current.Item1;
    var regionPreds = new List<Tuple<Block, Variable>>();
    var ownedPreds = new HashSet<Variable>();
    ownedMap[header] = ownedPreds;

    if (headPredicate != null) {
      predMap[header] = headPredicate;
      defMap[header] = headPredicate;
      regionPreds.Add(new Tuple<Block, Variable>(header, headPredicate));
    }

    while (i.MoveNext()) {
      var block = i.Current;

      if (block.Item2) {
        if (block.Item1 == header) {
          return;
        }
      }

      if (uni != null && uni.IsUniform(impl.Name, block.Item1)) {
        if (blockGraph.Headers.Contains(block.Item1)) {
          parentMap[block.Item1] = header;
          AssignPredicates(blockGraph, dom, pdom, headerDominance, i, headPredicate, ref predCount);
        }
        continue;
      }

      if (!block.Item2) {
        if (blockGraph.Headers.Contains(block.Item1)) {
          parentMap[block.Item1] = header;
          var loopPred = FreshPredicate(ref predCount);
          ownedPreds.Add(loopPred);
          AssignPredicates(blockGraph, dom, pdom, headerDominance, i, loopPred, ref predCount);
        } else {
          bool foundExisting = false;
          foreach (var regionPred in regionPreds) {
            if (dom.DominatedBy(block.Item1, regionPred.Item1) &&
                pdom.DominatedBy(regionPred.Item1, block.Item1)) {
              predMap[block.Item1] = regionPred.Item2;
              foundExisting = true;
              break;
            }
          }
          if (!foundExisting) {
            var condPred = FreshPredicate(ref predCount);
            predMap[block.Item1] = condPred;
            defMap[block.Item1] = condPred;
            var headerIterator = headerDominance.GetEnumerator();
            // Add the predicate to the loop header H that dominates the node (if one
            // exists) such that H does not dominate another header which also dominates
            // the node. Since predicates are owned by loop headers (or the program entry
            // node), this is the block 'closest' to block to which we are assigning a
            // that can be made to own the predicate.
            Block node = null;
            while (headerIterator.MoveNext()) {
              var current = headerIterator.Current;
              if (dom.DominatedBy(block.Item1, current)) {
                node = current;
                break;
              }
            }
            if (node != null) {
              ownedMap[node].Add(condPred);
            } else {
               // In this case the header is the program entry node.
              ownedPreds.Add(condPred);
            }
            regionPreds.Add(new Tuple<Block, Variable>(block.Item1, condPred));
          }
        }
      }
    }
  }
Example #44
0
 public abstract Element Eliminate(Element element, Variable v);
Example #45
0
        private void SetupRefinementCheck(Implementation impl, 
            out List<Variable> newLocalVars,
            out Dictionary<string, Variable> domainNameToInputVar, out Dictionary<string, Variable> domainNameToLocalVar, out Dictionary<Variable, Variable> ogOldGlobalMap)
        {
            pc = null;
            ok = null;
            alpha = null;
            beta = null;
            frame = null;

            newLocalVars = new List<Variable>();
            Program program = linearTypeChecker.program;
            ogOldGlobalMap = new Dictionary<Variable, Variable>();
            foreach (IdentifierExpr ie in globalMods)
            {
                Variable g = ie.Decl;
                LocalVariable l = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_global_old_{0}", g.Name), g.TypedIdent.Type));
                ogOldGlobalMap[g] = l;
                newLocalVars.Add(l);
            }

            Procedure originalProc = implMap[impl].Proc;
            ActionInfo actionInfo = civlTypeChecker.procToActionInfo[originalProc];
            if (actionInfo.createdAtLayerNum == this.layerNum)
            {
                pc = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "og_pc", Type.Bool));
                newLocalVars.Add(pc);
                ok = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "og_ok", Type.Bool));
                newLocalVars.Add(ok);
                Dictionary<Variable, Expr> alwaysMap = new Dictionary<Variable, Expr>();
                for (int i = 0; i < originalProc.InParams.Count; i++)
                {
                    alwaysMap[originalProc.InParams[i]] = Expr.Ident(impl.InParams[i]);
                }
                for (int i = 0; i < originalProc.OutParams.Count; i++)
                {
                    alwaysMap[originalProc.OutParams[i]] = Expr.Ident(impl.OutParams[i]);
                }
                Substitution always = Substituter.SubstitutionFromHashtable(alwaysMap);
                Dictionary<Variable, Expr> foroldMap = new Dictionary<Variable, Expr>();
                foreach (IdentifierExpr ie in globalMods)
                {
                    foroldMap[ie.Decl] = Expr.Ident(ogOldGlobalMap[ie.Decl]);
                }
                Substitution forold = Substituter.SubstitutionFromHashtable(foroldMap);
                frame = new HashSet<Variable>(civlTypeChecker.SharedVariables);
                foreach (Variable v in civlTypeChecker.SharedVariables)
                {
                    if (civlTypeChecker.globalVarToSharedVarInfo[v].hideLayerNum <= actionInfo.createdAtLayerNum ||
                        civlTypeChecker.globalVarToSharedVarInfo[v].introLayerNum > actionInfo.createdAtLayerNum)
                    {
                        frame.Remove(v);
                    }
                }
                AtomicActionInfo atomicActionInfo = actionInfo as AtomicActionInfo;
                if (atomicActionInfo == null)
                {
                    beta = Expr.True;
                    foreach (var v in frame)
                    {
                        beta = Expr.And(beta, Expr.Eq(Expr.Ident(v), foroldMap[v]));
                    }
                    alpha = Expr.True;
                }
                else
                {
                    Expr betaExpr = (new MoverCheck.TransitionRelationComputation(civlTypeChecker.program, atomicActionInfo, frame, new HashSet<Variable>())).TransitionRelationCompute(true);
                    beta = Substituter.ApplyReplacingOldExprs(always, forold, betaExpr);
                    Expr alphaExpr = Expr.True;
                    foreach (AssertCmd assertCmd in atomicActionInfo.gate)
                    {
                        alphaExpr = Expr.And(alphaExpr, assertCmd.Expr);
                        alphaExpr.Type = Type.Bool;
                    }
                    alpha = Substituter.Apply(always, alphaExpr);
                }
                foreach (Variable f in impl.OutParams)
                {
                    LocalVariable copy = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_old_{0}", f.Name), f.TypedIdent.Type));
                    newLocalVars.Add(copy);
                    ogOldGlobalMap[f] = copy;
                }
            }

            domainNameToInputVar = new Dictionary<string, Variable>();
            domainNameToLocalVar = new Dictionary<string, Variable>();
            {
                int i = impl.InParams.Count - linearTypeChecker.linearDomains.Count;
                foreach (string domainName in linearTypeChecker.linearDomains.Keys)
                {
                    Variable inParam = impl.InParams[i];
                    domainNameToInputVar[domainName] = inParam;
                    Variable l = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, inParam.Name + "_local", inParam.TypedIdent.Type));
                    domainNameToLocalVar[domainName] = l;
                    newLocalVars.Add(l);
                    i++;
                }
            }
        }
Example #46
0
        bool BruteForceCmd(Block b, int startidx, int endidx, Variable reachvar,
            Implementation impl, VerifierCallback callback)
        {
            Contract.Requires(b != null);
              Contract.Requires(reachvar != null);
              Contract.Requires(impl != null);
              Contract.Requires(callback != null);
              #region Modify Cmds
              List<Cmd> backup = b.Cmds;
              Contract.Assert(backup != null);
              List<Cmd> cs = new List<Cmd>();
              for (int i = 0; i < startidx; i++) {
            cs.Add(b.Cmds[i]);
              }
              for (int i = startidx; i <= endidx; i++) {
            Cmd c = b.Cmds[i];
            if (ContainsReachVariable(c)) {
              cs.Add(c);
              continue;
            }
            cs.Add(new AssertCmd(c.tok, Expr.True));
              }
              for (int i = endidx + 1; i < b.Cmds.Length; i++) {
            cs.Add(b.Cmds[i]);
              }

              b.Cmds = cs;
              #endregion

              #region Recheck
              ProverInterface.Outcome outcome = ProverInterface.Outcome.Undetermined;
              if (!ReCheckImpl(reachvar, impl, callback, out outcome)) {
            b.Cmds = backup;
            return false;
              }
              #endregion

              if (outcome == ProverInterface.Outcome.Valid) {
            return true;
              } else if (outcome == ProverInterface.Outcome.Invalid) {
            b.Cmds = backup;
            if (startidx >= endidx) {
              if (!ContainsReachVariable(b.Cmds[endidx])) {
            //                    Console.Write("   Witness (");
            //
            //                    ConsoleColor col = Console.ForegroundColor;
            //                    Console.ForegroundColor = ConsoleColor.White;
            //                    Console.Write("{0};{1}", b.Cmds[endidx].tok.line, b.Cmds[endidx].tok.col );
            //                    Console.ForegroundColor = col;
            //                    Console.Write("):   ");
            //                    Console.ForegroundColor = ConsoleColor.Yellow;
            //                    b.Cmds[endidx].Emit(new TokenTextWriter("<console>", Console.Out, false), 0);
            //                    Console.ForegroundColor = col;

            m_doomedCmds.Add(b.Cmds[endidx]);
            return true;
              } else {
            return false;
              }
            } else {
              int mid = startidx + (endidx - startidx) / 2;
              BruteForceCmd(b, startidx, mid, reachvar, impl, callback);
              BruteForceCmd(b, mid + 1, endidx, reachvar, impl, callback);
              return false; // This is pure random
            }
              } else {
            b.Cmds = backup;
            return false;
              }
        }
Example #47
0
 static string UniqueName(Variable variable, Procedure proc)
 {
   // TODO(wuestholz): Maybe we should define structural equality for variables instead.
   var scope = "#global_scope#";
   if (proc != null && !(variable is GlobalVariable || variable is Constant))
   {
     scope = proc.Name;
   }
   return string.Format("{0}.{1}", scope, variable.Name);
 }
Example #48
0
 bool ReCheckImpl(Variable reachvar, Implementation impl, VerifierCallback callback,
     out ProverInterface.Outcome outcome)
 {
     Contract.Requires(reachvar != null);
       Contract.Requires(impl != null);
       Contract.Requires(callback != null);
       Checker checker = FindCheckerFor(impl, 1000);
       Contract.Assert(checker != null);
       DoomCheck dc = new DoomCheck(impl, this.exitBlock,  checker, m_UncheckableBlocks);
       dc.ErrorHandler = new DoomErrorHandler(dc.Label2Absy, callback);
       outcome = ProverInterface.Outcome.Undetermined;
       List<Variable> rv = new List<Variable>();
       rv.Add(reachvar);
       if (!dc.CheckLabel(rv,null, out outcome)) {
     checker.Close();
     return false;
       }
       checker.Close();
       return true;
 }
Example #49
0
 public void AddVariable(Variable var, bool global)
 {
     Contract.Requires(var != null);
       var previous = FindVariable(cce.NonNull(var.Name), !global);
       if (previous == null) {
     varContext.VarSymbols.Add(var.Name, var);
       } else {
     var r = (Variable)SelectNonExtern(var, previous);
     if (r == null) {
       Error(var, "more than one declaration of variable name: {0}", var.Name);
     } else {
       varContext.VarSymbols[var.Name] = r;
     }
       }
 }
Example #50
0
 /// <summary>
 /// Use this constructor for translating expressions that do occur within
 /// the context of the statements in a method body.
 /// </summary>
 public ExpressionTraverser(Sink sink, StatementTraverser/*?*/ statementTraverser) {
   this.sink = sink;
   HeapVariable = sink.HeapVariable;
   this.StmtTraverser = statementTraverser;
   TranslatedExpressions = new Stack<Bpl.Expr>();
 }
Example #51
0
        bool BruteForceCESearch(Variable reachvar, Implementation impl, VerifierCallback callback,
            Dictionary<Block, List<Cmd>> cmdbackup, int startidx, int endidx)
        {
            Contract.Requires(reachvar != null);
              Contract.Requires(impl != null);
              Contract.Requires(callback != null);
              Contract.Requires(cce.NonNullElements(cmdbackup));
              #region Modify implementation
              for (int i = startidx; i <= endidx; i++) {
            if (_copiedBlock.Contains(impl.Blocks[i]))
              continue;
            List<Cmd> cs = new List<Cmd>();
            cmdbackup.Add(impl.Blocks[i], impl.Blocks[i].Cmds);
            foreach (Cmd c in impl.Blocks[i].Cmds) {
              Contract.Assert(c != null);
              if (ContainsReachVariable(c)) {
            cs.Add(c);
            continue;
              }
              AssertCmd ac = c as AssertCmd;
              AssumeCmd uc = c as AssumeCmd;
              if (ac != null) {
            cs.Add(new AssertCmd(ac.tok, Expr.True));
              } else if (uc != null) {
            cs.Add(new AssertCmd(uc.tok, Expr.True));
              } else {
            cs.Add(c);
              }
            }
            impl.Blocks[i].Cmds = cs;
              }
              #endregion

              ProverInterface.Outcome outcome = ProverInterface.Outcome.Undetermined;
              if (!ReCheckImpl(reachvar, impl, callback, out outcome)) {
            UndoBlockModifications(impl, cmdbackup, startidx, endidx);
            return false;
              }
              if (outcome == ProverInterface.Outcome.Valid) {
            return true;
              } else if (outcome == ProverInterface.Outcome.Invalid) {
            UndoBlockModifications(impl, cmdbackup, startidx, endidx);
            int mid = startidx + (endidx - startidx) / 2;
            if (startidx >= endidx) {
              // Now we found an interesting Block and we have to
              // search for the interesting statements.
              int cmdcount = impl.Blocks[endidx].Cmds.Length;
              BruteForceCmd(impl.Blocks[endidx], 0, cmdcount / 2 - 1, reachvar, impl, callback);
              BruteForceCmd(impl.Blocks[endidx], cmdcount / 2, cmdcount - 1, reachvar, impl, callback);
              return true;
            } else {
              BruteForceCESearch(reachvar, impl, callback, cmdbackup, startidx, mid);
              BruteForceCESearch(reachvar, impl, callback, cmdbackup, mid + 1, endidx);
              return true;
            }
              } else {
            UndoBlockModifications(impl, cmdbackup, startidx, endidx);
            return false;
              }
        }
Example #52
0
 public override string getVarUName(Variable v)
 {
     Debug.Assert(v.Name == v.TypedIdent.Name);
     return(program.getVarUName(v));
 }