Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/DataFlowAnalysisBase.cs

@@ -0,0 +1,164 @@
+// 
+// DataFlowAnalysisBase.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	abstract class DataFlowAnalysisBase<AState> :
+		IEqualityComparer<APC> {
+		protected ICFG CFG;
+		protected Dictionary<APC, AState> JoinState;
+		protected PriorityQueue<APC> pending;
+		private IWidenStrategy widen_strategy;
+
+		protected DataFlowAnalysisBase (ICFG cfg)
+		{
+			this.CFG = cfg;
+			this.pending = new PriorityQueue<APC> (WorkingListComparer);
+			this.JoinState = new Dictionary<APC, AState> (this);
+			this.widen_strategy = null;
+		}
+
+		#region IEqualityComparer<APC> Members
+		bool IEqualityComparer<APC>.Equals (APC x, APC y)
+		{
+			return x.Equals (y);
+		}
+
+		int IEqualityComparer<APC>.GetHashCode (APC obj)
+		{
+			return obj.GetHashCode ();
+		}
+		#endregion
+
+		public void Initialize (APC entryPoint, AState state)
+		{
+			this.JoinState.Add (entryPoint, state);
+			this.pending.Enqueue (entryPoint);
+		}
+
+		public virtual void ComputeFixPoint ()
+		{
+			this.widen_strategy = new EdgeBasedWidening (20);
+
+			while (this.pending.Count > 0) {
+				APC next = this.pending.Dequeue ();
+				AState state = MutableVersion (this.JoinState [next], next);
+
+				APC cur;
+				bool repeatOuter = false;
+				do {
+					cur = next;
+					if (!IsBottom (cur, state)) {
+						state = Transfer (cur, state);
+					} else {
+						repeatOuter = true;
+						break;
+					}
+				} while (HasSingleSuccessor (cur, out next) && !RequiresJoining (next));
+
+				if (repeatOuter)
+					continue;
+
+				foreach (APC successorAPC in Successors (cur)) {
+					if (!IsBottom (successorAPC, state))
+						PushState (cur, successorAPC, state);
+				}
+			}
+		}
+
+		protected virtual void Dump (AState state)
+		{
+		}
+
+		public IEnumerable<KeyValuePair<APC, AState>> States ()
+		{
+			return this.JoinState;
+		}
+
+		protected abstract IEnumerable<APC> Successors (APC pc);
+
+		protected virtual void PushState (APC current, APC next, AState state)
+		{
+			state = ImmutableVersion (state, next);
+			if (RequiresJoining (next)) {
+				if (!JoinStateAtBlock (new Pair<APC, APC> (current, next), state))
+					return;
+				this.pending.Enqueue (next);
+			} else {
+				this.JoinState [next] = state;
+				this.pending.Enqueue (next);
+			}
+		}
+
+		private bool JoinStateAtBlock (Pair<APC, APC> edge, AState state)
+		{
+			AState existingState;
+			if (this.JoinState.TryGetValue (edge.Value, out existingState)) {
+				bool widen = this.widen_strategy.WantToWiden (edge.Key, edge.Value, IsBackEdge (edge.Key, edge.Value));
+				AState joinedState;
+				bool result = Join (edge, state, existingState, out joinedState, widen);
+				if (result)
+					this.JoinState [edge.Value] = ImmutableVersion (joinedState, edge.Value);
+				return result;
+			}
+
+			this.JoinState.Add (edge.Value, state);
+			return true;
+		}
+
+		protected abstract bool IsBackEdge (APC from, APC to);
+
+		protected abstract int WorkingListComparer (APC a, APC b);
+
+		protected abstract bool Join (Pair<APC, APC> edge, AState newState, AState existingState, out AState joinedState, bool widen);
+
+		protected abstract bool RequiresJoining (APC pc);
+
+		protected abstract bool HasSingleSuccessor (APC pc, out APC next);
+
+		protected abstract bool IsBottom (APC pc, AState state);
+
+		protected abstract AState Transfer (APC pc, AState state);
+
+		protected abstract AState MutableVersion (AState state, APC at);
+		protected abstract AState ImmutableVersion (AState state, APC at);
+
+		public void PrintStatesAtJoinPoints (TextWriter tw)
+		{
+			foreach (APC apc in this.JoinState.Keys) {
+				string str = this.JoinState [apc].ToString ().Replace (Environment.NewLine, Environment.NewLine + "   ");
+				tw.WriteLine ("Block {0}, PC {1}: {2}", apc.Block, apc.Index, str);
+			}
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/EdgeBasedWidening.cs

@@ -0,0 +1,46 @@
+// 
+// EdgeBasedWidening.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	class EdgeBasedWidening : StepWidening<Pair<APC, APC>> {
+		public EdgeBasedWidening (int n)
+			: base (n)
+		{
+		}
+
+		#region Overrides of StepWidening<Pair<APC,APC>>
+		protected override Pair<APC, APC> MakeIndex (APC from, APC to)
+		{
+			return new Pair<APC, APC> (from, to);
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/EdgeConverter.cs

@@ -0,0 +1,31 @@
+// 
+// EdgeConverter.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	delegate AbstractState EdgeConverter<Label, AbstractState, EdgeData> (Label from, Label to, bool isJoinPoint, EdgeData data, AbstractState newState);
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/ForwardAnalysis.cs

@@ -0,0 +1,151 @@
+// 
+// ForwardAnalysis.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using System;
+using System.IO;
+using Mono.CodeContracts.Static.AST.Visitors;
+using Mono.CodeContracts.Static.Analysis;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+using Mono.CodeContracts.Static.Providers;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	class ForwardAnalysis<AbstractState, EdgeData> :
+		ForwardDataFlowAnalysisBase<AbstractState>,
+		IFixPointInfo<APC, AbstractState> {
+		private readonly Action<Pair<AbstractState, TextWriter>> dumper;
+		private readonly EdgeConverter<APC, AbstractState, EdgeData> edge_converter;
+		private readonly Func<APC, APC, EdgeData> edge_data_getter;
+		private readonly Func<AbstractState, AbstractState> immutable_version;
+		private readonly Func<APC, AbstractState, bool> is_bottom;
+		private readonly Joiner<APC, AbstractState> joiner;
+		private readonly Func<AbstractState, AbstractState> mutable_version;
+		private readonly Func<APC, AbstractState, AbstractState> transfer;
+
+		public ForwardAnalysis (ICFG cfg,
+		                        Func<APC, AbstractState, AbstractState> transfer,
+		                        Joiner<APC, AbstractState> joiner,
+		                        Func<AbstractState, AbstractState> immutableVersion,
+		                        Func<AbstractState, AbstractState> mutableVersion,
+		                        EdgeConverter<APC, AbstractState, EdgeData> edgeConverter,
+		                        Func<APC, APC, EdgeData> edgeDataGetter,
+		                        Func<APC, AbstractState, bool> isBottom,
+		                        Action<Pair<AbstractState, TextWriter>> dumper) : base (cfg)
+		{
+			this.transfer = transfer;
+			this.joiner = joiner;
+			this.immutable_version = immutableVersion;
+			this.mutable_version = mutableVersion;
+			this.edge_converter = edgeConverter;
+			this.edge_data_getter = edgeDataGetter;
+			this.is_bottom = isBottom;
+			this.dumper = dumper;
+		}
+
+		#region IFixPointInfo<APC,AbstractState> Members
+		public bool PreStateLookup (APC pc, out AbstractState state)
+		{
+			return GetPreState (pc, out state);
+		}
+
+		public bool PostStateLookup (APC pc, out AbstractState state)
+		{
+			return GetPostState (pc, out state);
+		}
+		#endregion
+
+		public static ForwardAnalysis<AbstractState, EdgeData> Make<Source, Dest, Context> (
+			IILDecoder<APC, Source, Dest, Context, EdgeData> decoder,
+			IAnalysis<APC, AbstractState, IILVisitor<APC, Source, Dest, AbstractState, AbstractState>, EdgeData> analysis)
+			where Context : IMethodContextProvider
+		{
+			IILVisitor<APC, Source, Dest, AbstractState, AbstractState> visitor = analysis.GetVisitor ();
+			var forwardAnalysisSolver = new ForwardAnalysis<AbstractState, EdgeData> (
+				decoder.ContextProvider.MethodContext.CFG,
+				(pc, state) => decoder.ForwardDecode<AbstractState, AbstractState, IILVisitor<APC, Source, Dest, AbstractState, AbstractState>> (pc, visitor, state),
+				analysis.Join,
+				analysis.ImmutableVersion,
+				analysis.MutableVersion,
+				analysis.EdgeConversion,
+				decoder.EdgeData,
+				(pc, state) => {
+					if (!decoder.IsUnreachable (pc))
+						return analysis.IsBottom (pc, state);
+
+					return true;
+				}, 
+				analysis.Dump
+				);
+
+			analysis.SaveFixPointInfo (forwardAnalysisSolver);
+			return forwardAnalysisSolver;
+		}
+
+		protected override void Dump (AbstractState state)
+		{
+			this.dumper (new Pair<AbstractState, TextWriter> (state, Console.Out));
+		}
+
+		protected override void PushState (APC from, APC next, AbstractState state)
+		{
+			EdgeData data = this.edge_data_getter (from, next);
+			AbstractState pushState = this.edge_converter (from, next, RequiresJoining (next), data, state);
+			base.PushState (from, next, pushState);
+		}
+
+		protected override bool Join (Pair<APC, APC> edge, AbstractState newState, AbstractState existingState, out AbstractState joinedState, bool widen)
+		{
+			bool weaker;
+			joinedState = this.joiner (edge, newState, existingState, out weaker, widen);
+
+			return weaker;
+		}
+
+		protected override bool IsBottom (APC pc, AbstractState state)
+		{
+			return this.is_bottom (pc, state);
+		}
+
+		protected override AbstractState Transfer (APC pc, AbstractState state)
+		{
+			AbstractState resultState = this.transfer (pc, state);
+
+			return resultState;
+		}
+
+		protected override AbstractState MutableVersion (AbstractState state, APC at)
+		{
+			return this.mutable_version (state);
+		}
+
+		protected override AbstractState ImmutableVersion (AbstractState state, APC at)
+		{
+			return this.immutable_version (state);
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/ForwardDataFlowAnalysisBase.cs

@@ -0,0 +1,153 @@
+// 
+// ForwardDataFlowAnalysisBase.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	abstract class ForwardDataFlowAnalysisBase<AState> : DataFlowAnalysisBase<AState> {
+		private readonly Dictionary<APC, AState> post_state = new Dictionary<APC, AState> ();
+
+		protected ForwardDataFlowAnalysisBase (ICFG cfg) : base (cfg)
+		{
+		}
+
+		public bool GetPreState (APC pc, out AState state)
+		{
+			bool noInfo;
+			state = GetPreState (pc, default(AState), out noInfo);
+			return !noInfo;
+		}
+
+		public AState GetPreStateWithDefault (APC apc, AState ifMissing)
+		{
+			bool noInfo;
+			AState preState = GetPreState (apc, default(AState), out noInfo);
+			return noInfo ? ifMissing : preState;
+		}
+
+		private AState GetPreState (APC apc, AState ifMissing, out bool noInfo)
+		{
+			Sequence<APC> rest = null;
+			APC tmp = apc;
+			APC singlePredecessor;
+			AState state;
+			bool weHaveState;
+			while (!(weHaveState = this.JoinState.TryGetValue (tmp, out state)) &&
+			       !RequiresJoining (tmp) && this.CFG.HasSinglePredecessor (tmp, out singlePredecessor)) {
+				tmp = singlePredecessor;
+
+				rest = rest.Cons (tmp);
+			}
+
+			if (!weHaveState) {
+				noInfo = true;
+				return ifMissing;
+			}
+
+			bool listWasNotEmpty = rest != null;
+			while (rest != null) {
+				if (IsBottom (rest.Head, state)) {
+					noInfo = false;
+					return state;
+				}
+				state = MutableVersion (state, rest.Head);
+				state = Transfer (rest.Head, state);
+				if (IsBottom (rest.Head, state)) {
+					noInfo = false;
+					return state;
+				}
+
+				rest = rest.Tail;
+				if (rest != null)
+					this.JoinState.Add (rest.Head, ImmutableVersion (state, rest.Head));
+			}
+
+			if (listWasNotEmpty)
+				this.JoinState.Add (apc, ImmutableVersion (state, apc));
+
+			noInfo = false;
+			return state;
+		}
+
+		public bool GetPostState (APC apc, out AState result)
+		{
+			if (this.post_state.TryGetValue (apc, out result))
+				return true;
+
+			APC singleSuccessor;
+			if (apc.Block.Count <= apc.Index)
+				return GetPreState (apc, out result);
+
+			if (this.CFG.HasSingleSuccessor (apc, out singleSuccessor) && !RequiresJoining (singleSuccessor))
+				return GetPreState (singleSuccessor, out result);
+
+			AState ifFound;
+			if (!GetPreState (apc, out ifFound))
+				return false;
+
+			result = MutableVersion (ifFound, apc);
+			result = Transfer (apc, result);
+
+			this.post_state.Add (apc, result);
+			return true;
+		}
+
+		public void Run (AState startState)
+		{
+			Initialize (this.CFG.Entry, startState);
+			ComputeFixPoint ();
+		}
+
+		protected override int WorkingListComparer (APC a, APC b)
+		{
+			return b.Block.ReversePostOrderIndex - a.Block.ReversePostOrderIndex;
+		}
+
+		protected override bool RequiresJoining (APC pc)
+		{
+			return this.CFG.IsJoinPoint (pc);
+		}
+
+		protected override bool HasSingleSuccessor (APC pc, out APC next)
+		{
+			return this.CFG.HasSingleSuccessor (pc, out next);
+		}
+
+		protected override IEnumerable<APC> Successors (APC pc)
+		{
+			return this.CFG.Successors (pc);
+		}
+
+		protected override bool IsBackEdge (APC from, APC to)
+		{
+		    return CFG.IsForwardBackEdge (from, to);
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/IAnalysis.cs

@@ -0,0 +1,54 @@
+// 
+// IAnalysis.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using System;
+using System.IO;
+
+using Mono.CodeContracts.Static.AST.Visitors;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+using Mono.CodeContracts.Static.Proving;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	interface IAnalysis<Label, AbstractState, Visitor, EdgeData> {
+		Visitor GetVisitor ();
+		AbstractState Join (Pair<Label, Label> edge, AbstractState newstate, AbstractState prevstate, out bool weaker, bool widen);
+		AbstractState ImmutableVersion (AbstractState arg);
+		AbstractState MutableVersion (AbstractState arg);
+		AbstractState EdgeConversion (APC from, APC to, bool isJoinPoint, EdgeData data, AbstractState state);
+		bool IsBottom (Label pc, AbstractState state);
+		Predicate<Label> SaveFixPointInfo (IFixPointInfo<Label, AbstractState> fixPointInfo);
+		void Dump (Pair<AbstractState, TextWriter> pair);
+	}
+
+        interface IAbstractAnalysis<TDomain, TVar> : IAnalysis<APC, TDomain, IILVisitor<APC, TVar, TVar, TDomain, TDomain>, IImmutableMap<TVar, Sequence<TVar>>> {
+                TDomain TopValue ();
+                TDomain BottomValue ();
+                IFactQuery<BoxedExpression, TVar> FactQuery (IFixPointInfo<APC, TDomain> fixpoint);
+        }
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/IFixPointInfo.cs

@@ -0,0 +1,34 @@
+// 
+// IFixPointInfo.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	interface IFixPointInfo<Label, AState> {
+		bool PreStateLookup (Label pc, out AState state);
+		bool PostStateLookup (Label pc, out AState state);
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/IWidenStrategy.cs

@@ -0,0 +1,35 @@
+// 
+// IWidenStrategy.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using Mono.CodeContracts.Static.ControlFlow;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	interface IWidenStrategy {
+		bool WantToWiden (APC from, APC to, bool isBackEdge);
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/Joiner.cs

@@ -0,0 +1,33 @@
+// 
+// Joiner.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	delegate AbstractState Joiner<Label, AbstractState> (Pair<Label, Label> edge, AbstractState newState, AbstractState prevState, out bool weaker, bool widen);
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.DataFlowAnalysis/StepWidening.cs

@@ -0,0 +1,60 @@
+// 
+// StepWidening.cs
+// 
+// Authors:
+// 	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// 
+
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.ControlFlow;
+
+namespace Mono.CodeContracts.Static.DataFlowAnalysis {
+	abstract class StepWidening<Index> : IWidenStrategy {
+		private readonly int N;
+		private readonly Dictionary<Index, int> widenCounter;
+
+		protected StepWidening (int n)
+		{
+			this.widenCounter = new Dictionary<Index, int> ();
+			this.N = n;
+		}
+
+		protected abstract Index MakeIndex (APC from, APC to);
+
+		#region Implementation of IWidenStrategy
+		public bool WantToWiden (APC from, APC to, bool isBackEdge)
+		{
+			if (!isBackEdge)
+				return false;
+
+			Index key = MakeIndex (from, to);
+			if (this.widenCounter.ContainsKey (key))
+				this.widenCounter [key] = this.widenCounter [key] + 1;
+			else
+				this.widenCounter [key] = 1;
+			return this.N < this.widenCounter [key];
+		}
+		#endregion
+	}
+}