Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.StackAnalysis/APCMap.cs

@@ -0,0 +1,92 @@
+// 
+// APCMap.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.Analysis.StackAnalysis {
+	class APCMap<T> {
+		private readonly Dictionary<int, T>[] block_map;
+		private IImmutableIntMap<bool> call_on_this_map;
+
+		public APCMap (Subroutine parent)
+		{
+			this.block_map = new Dictionary<int, T>[parent.BlockCount];
+			this.call_on_this_map = ImmutableIntMap<bool>.Empty;
+		}
+
+		public T this [APC key]
+		{
+			get
+			{
+				T value;
+				if (!TryGetValue (key, out value))
+					throw new KeyNotFoundException ();
+				return value;
+			}
+		}
+
+		public void Add (APC pc, T value)
+		{
+			Dictionary<int, T> pcBlockMap = this.block_map [pc.Block.Index];
+			if (pcBlockMap == null)
+				this.block_map [pc.Block.Index] = pcBlockMap = new Dictionary<int, T> ();
+
+			pcBlockMap.Add (pc.Index, value);
+		}
+
+		public bool TryGetValue (APC pc, out T obj)
+		{
+			Dictionary<int, T> dictionary = this.block_map [pc.Block.Index];
+			if (dictionary != null)
+				return dictionary.TryGetValue (pc.Index, out obj);
+
+			obj = default(T);
+			return false;
+		}
+
+		public bool ContainsKey (APC pc)
+		{
+			Dictionary<int, T> dictionary = this.block_map [pc.Block.Index];
+			if (dictionary == null)
+				return false;
+			return dictionary.ContainsKey (pc.Index);
+		}
+
+		public bool IsCallOnThis (APC key)
+		{
+			return this.call_on_this_map [key.Block.Index];
+		}
+
+		public void AddCallOnThis (APC pc)
+		{
+			this.call_on_this_map = this.call_on_this_map.Add (pc.Block.Index, true);
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.StackAnalysis/SequenceGenerator.cs

@@ -0,0 +1,67 @@
+// 
+// SequenceGenerator.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;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.StackAnalysis {
+	class SequenceGenerator : IIndexable<int>, IEnumerable<int> {
+		private readonly short count;
+		private readonly short from;
+
+		public SequenceGenerator (int from, int count)
+		{
+			this.from = checked((short) from);
+			this.count = checked((short) count);
+		}
+
+		#region Implementation of IIndexable<int>
+		public int Count {
+			get { return this.count; }
+		}
+
+		public int this [int index] {
+			get { return this.from + index; }
+		}
+		#endregion
+
+		#region Implementation of IEnumerable
+		public IEnumerator<int> GetEnumerator ()
+		{
+			for (int i = 0; i < this.count; i++)
+				yield return this [i];
+		}
+
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			return GetEnumerator ();
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.StackAnalysis/StackDepthFactory.cs

@@ -0,0 +1,41 @@
+// 
+// StackDepthFactory.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;
+using Mono.CodeContracts.Static.Providers;
+
+namespace Mono.CodeContracts.Static.Analysis.StackAnalysis {
+	static class StackDepthFactory {
+		public static IILDecoder<APC, int, int, IStackContextProvider, Dummy> Create<TContext> (IILDecoder<APC, Dummy, Dummy, TContext, Dummy> ilDecoder,
+		                                                                                IMetaDataProvider metadataDecoder) where TContext : IMethodContextProvider
+		{
+			return new StackDepthProvider<TContext> (ilDecoder, metadataDecoder);
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.StackAnalysis/StackInfo.cs

@@ -0,0 +1,127 @@
+// 
+// StackInfo.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.Analysis.StackAnalysis {
+	struct StackInfo {
+		private StackInfo<object> stack;
+
+		public int Depth {
+			get { return this.stack.Depth; }
+		}
+
+		public object this [int offset] {
+			get { return this.stack [offset]; }
+		}
+
+		public StackInfo (int depth, int capacity)
+		{
+			this.stack = new StackInfo<object> (depth, capacity);
+		}
+
+		private StackInfo (StackInfo<object> copy)
+		{
+			this.stack = copy;
+		}
+
+		public StackInfo Pop (int slots)
+		{
+			return new StackInfo (this.stack.Pop (slots));
+		}
+
+		public StackInfo Push ()
+		{
+			this.stack.Push (null);
+			return this;
+		}
+
+		public StackInfo PushThis ()
+		{
+			this.stack.Push (true);
+			return this;
+		}
+
+		public StackInfo Push<T> (T target)
+		{
+			this.stack.Push (target);
+			return this;
+		}
+
+		public void Adjust (int delta)
+		{
+			if (delta == 0)
+				return;
+			if (delta < 0)
+				this.stack.Pop (-delta);
+			for (int i = 0; i < delta; ++i)
+				Push ();
+		}
+
+		public bool IsThis (int offset)
+		{
+			return As<bool> (offset);
+		}
+
+		public bool TryGet<T> (int offset, out T target)
+		{
+			object o = this [offset];
+			if (o is T) {
+				target = (T) o;
+				return true;
+			}
+			target = default(T);
+			return false;
+		}
+
+		private T As<T> (int offset)
+		{
+			T res;
+			TryGetTarget (offset, out res);
+			return res;
+		}
+
+		public StackInfo Clone ()
+		{
+			return new StackInfo (new StackInfo<object> (this.stack));
+		}
+
+		public override string ToString ()
+		{
+			return this.stack.ToString ();
+		}
+
+		public bool TryGetTarget<T> (int offset, out T target)
+		{
+			if (this [offset] is T) {
+				target = (T) this [offset];
+				return true;
+			}
+			target = default(T);
+			return false;
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.StackAnalysis/StackInfo`1.cs

@@ -0,0 +1,82 @@
+// 
+// StackInfo`1.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.Analysis.StackAnalysis {
+	struct StackInfo<T> {
+		private readonly T[] stack;
+		private int depth;
+
+		public StackInfo (int depth, int capacity)
+		{
+			this.depth = depth;
+			this.stack = new T[capacity];
+		}
+
+		public StackInfo (StackInfo<T> that)
+		{
+			this.depth = that.depth;
+			this.stack = (T[]) that.stack.Clone ();
+		}
+
+		public int Depth { 
+			get { return this.depth; }
+		}
+
+		public T this [int offset] {
+			get {
+				int index = this.depth - 1 - offset;
+				if (index >= 0 && index < this.stack.Length)
+					return this.stack [index];
+				return default(T);
+			}
+		}
+
+		public StackInfo<T> Pop (int slots)
+		{
+			for (int i = this.depth - slots; i < this.depth; ++i) {
+				if (i < this.stack.Length)
+					this.stack [i] = default(T);
+			}
+			this.depth -= slots;
+			return this;
+		}
+
+		public void Push (T info)
+		{
+			int index = this.depth;
+			if (index < this.stack.Length)
+				this.stack [index] = info;
+			++this.depth;
+		}
+
+		public override string ToString ()
+		{
+			return this.depth.ToString ();
+		}
+	}
+}