source2/IL2PCU/Cosmos.IL2CPU.X86/IL/Newobj.cs

@@ -16,7 +16,8 @@ namespace Cosmos.IL2CPU.X86.IL
 		public override void Execute(MethodInfo aMethod, ILOpCode aOpCode)
 		{
 			OpMethod xMethod = (OpMethod)aOpCode;
-            // Is this checking for plugs?
+			string xCurrentLabel = GetLabel(aMethod, aOpCode);
+			// TODO: enable this again
 			// if (DynamicMethodEmit.GetHasDynamicMethod(CtorDef)) {
 			//   CtorDef = DynamicMethodEmit.GetDynamicMethod(CtorDef);
 			// }
@@ -75,17 +76,19 @@ namespace Cosmos.IL2CPU.X86.IL
 				int xExtraSize = 20;
 				new CPUx86.Push { DestinationValue = (uint)(xMemSize + xExtraSize) };
 
+				// todo: probably we want to check for exceptions after calling Alloc
 				new CPUx86.Call { DestinationLabel = MethodInfoLabelGenerator.GenerateLabelName(GCImplementationRefs.AllocNewObjectRef) };
-                new CPUx86.Test { DestinationReg = CPUx86.Registers.ECX, SourceValue = 2 };
 				new CPUx86.Push { DestinationReg = CPUx86.Registers.ESP, DestinationIsIndirect = true };
 				new CPUx86.Push { DestinationReg = CPUx86.Registers.ESP, DestinationIsIndirect = true };
 				new CPUx86.Push { DestinationReg = CPUx86.Registers.ESP, DestinationIsIndirect = true };
 				new CPUx86.Push { DestinationReg = CPUx86.Registers.ESP, DestinationIsIndirect = true };
-                //var xIncRefInfo = aServiceProvider.GetService<IMetaDataInfoService>().GetMethodInfo( GCImplementationRefs.IncRefCountRef, false );
-                // TODO: Why call incref twice?
-                //                 new Assembler.X86.Call { DestinationLabel = xIncRefInfo.LabelName };
-                //                 new CPUx86.Call { DestinationLabel = xIncRefInfo.LabelName };
 				
+				// We IncRef here twice because it's effectively pushed on the stack twice:
+				// * once for the .ctor parameter
+				// * once for the "returnvalue" of the newobj il op
+
+				// todo: probably we want to check for exceptions after calling IncRef
+				new CPUx86.Call { DestinationLabel = MethodInfoLabelGenerator.GenerateLabelName(GCImplementationRefs.IncRefCountRef) };
 				new CPUx86.Call { DestinationLabel = MethodInfoLabelGenerator.GenerateLabelName(GCImplementationRefs.IncRefCountRef) };
 
 				uint xObjSize = 0;
@@ -120,8 +123,7 @@ namespace Cosmos.IL2CPU.X86.IL
 
 				new CPUx86.Call { DestinationLabel = MethodInfoLabelGenerator.GenerateLabelName(xMethod.Value) };
 				new CPUx86.Test { DestinationReg = CPUx86.Registers.ECX, SourceValue = 2 };
-                //new CPUx86.ConditionalJump { Condition = CPUx86.ConditionalTestEnum.Equal, DestinationLabel = aCurrentLabel + "_NO_ERROR_4" };
+				new CPUx86.ConditionalJump { Condition = CPUx86.ConditionalTestEnum.Equal, DestinationLabel = xCurrentLabel + "_NO_ERROR_4" };
-								throw new Exception("Notimpl");
 
 				//for( int i = 1; i < aCtorMethodInfo.Arguments.Length; i++ )
 				//{
@@ -134,19 +136,15 @@ namespace Cosmos.IL2CPU.X86.IL
 				//    };
 				//}
 				PushAlignedParameterSize(xMethod.Value);
-
+// an exception occurred, we need to cleanup the stack, and jump to the exit
 				new CPUx86.Add { DestinationReg = CPUx86.Registers.ESP, SourceValue = 4 };
-								//foreach( StackContent xStackInt in Assembler.Stack )
+				foreach (var xStackInt in Assembler.Stack)
-								//{
+				{
-								//    new CPUx86.Add { DestinationReg = CPUx86.Registers.ESP, SourceValue = ( uint )xStackInt.Size };
+					new CPUx86.Add { DestinationReg = CPUx86.Registers.ESP, SourceValue = (uint)xStackInt.Size };
-								//}
+				}
-                //Call.EmitExceptionLogic( aAssembler,
+				JumpToExceptionExit(aMethod);
-                //                        ( uint )aCurrentILOffset,
+
-                //                        aCurrentMethodInformation,
+				new Label(xCurrentLabel + "_NO_ERROR_4");
-                //                        aCurrentLabel + "_NO_ERROR_4",
-                //                        false,
-                //                        null );
-                //new Label( aCurrentLabel + "_NO_ERROR_4" );
 				new CPUx86.Pop { DestinationReg = CPUx86.Registers.EAX };
 
 				//for( int i = 1; i < aCtorMethodInfo.Arguments.Length; i++ )
@@ -163,7 +161,6 @@ namespace Cosmos.IL2CPU.X86.IL
 
 				new CPUx86.Push { DestinationReg = CPUx86.Registers.EAX };
 				Assembler.Stack.Push(4, xMethod.Value.DeclaringType);
-                throw new NotImplementedException();
 			}
 			else
 			{
@@ -224,6 +221,17 @@ namespace Cosmos.IL2CPU.X86.IL
 			}
 		}
 
+		private void JumpToExceptionExit(MethodInfo aMethod)
+		{
+			// todo: port to numeric labels
+			new CPUx86.Jump{DestinationLabel= MethodInfoLabelGenerator.GenerateLabelName(aMethod.MethodBase) + "___EXCEPTION___EXIT"};
+		}
+
+		private void JumpToExit(MethodInfo aMethod)
+		{
+			throw new NotImplementedException();
+		}
+
 		private uint Align(uint aSize, uint aAlign)
 		{
 			return aSize % 4 == 0 ? aSize : ((aSize / aAlign) * aAlign) + 1;
@@ -291,84 +299,5 @@ namespace Cosmos.IL2CPU.X86.IL
 		// 
 		//         private string mNextLabel;
 		// }
-
-        //TODO: Likely this is used by other things besides newobj
-        // and thus should be moved to a different location
-        private uint GetFieldStorageSize( Type aType )
-        {
-            if( aType.FullName == "System.Void" )
-            {
-                return 0;
-            }
-            else if( ( !aType.IsValueType && aType.IsClass ) || aType.IsInterface )
-            {
-                return 4;
-            }
-            switch( aType.FullName )
-            {
-                case "System.Char":
-                    return 2;
-                case "System.Byte":
-                case "System.SByte":
-                    return 1;
-                case "System.UInt16":
-                case "System.Int16":
-                    return 2;
-                case "System.UInt32":
-                case "System.Int32":
-                    return 4;
-                case "System.UInt64":
-                case "System.Int64":
-                    return 8;
-                //TODO: for now hardcode IntPtr and UIntPtr to be 32-bit
-                case "System.UIntPtr":
-                case "System.IntPtr":
-                    return 4;
-                case "System.Boolean":
-                    return 1;
-                case "System.Single":
-                    return 4;
-                case "System.Double":
-                    return 8;
-                case "System.Decimal":
-                    return 16;
-                case "System.Guid":
-                    return 16;
-                case "System.Enum":
-                    return 4;
-                case "System.DateTime":
-                    return 8;
-            }
-            if( aType.FullName != null && aType.FullName.EndsWith( "*" ) )
-            {
-                // pointer
-                return 4;
-            }
-            // array
-            //TypeSpecification xTypeSpec = aType as TypeSpecification;
-            //if (xTypeSpec != null) {
-            //    return 4;
-            //}
-            if( aType.IsEnum )
-            {
-                return GetFieldStorageSize( aType.GetField( "value__" ).FieldType );
-            }
-            if( aType.IsValueType )
-            {
-                var xSla = aType.StructLayoutAttribute;
-                if( xSla != null )
-                {
-                    if( xSla.Size > 0 )
-                    {
-                        return ( uint )xSla.Size;
-                    }
-                }
-            }
-            uint xResult;
-            //GetTypeFieldInfo(aType,  out xResult);
-            throw new Exception( "TODO" );
-            return xResult;
-        }
-
 	}
 }

source2/IL2PCU/Cosmos.IL2CPU.X86/IL/Stloc.cs

@@ -1,29 +1,61 @@
 using System;
+using Cosmos.IL2CPU.ILOpCodes;
+using CPUx86 = Indy.IL2CPU.Assembler.X86;
+using System.Collections.Generic;
+using System.Reflection;
+using Indy.IL2CPU;
 
 namespace Cosmos.IL2CPU.X86.IL
 {
 	[Cosmos.IL2CPU.OpCode(ILOpCode.Code.Stloc)]
 	public class Stloc : ILOp
 	{
-		public Stloc(Cosmos.IL2CPU.Assembler aAsmblr):base(aAsmblr)
+		public Stloc(Cosmos.IL2CPU.Assembler aAsmblr)
+			: base(aAsmblr)
 		{
 		}
 
-    public override void Execute(MethodInfo aMethod, ILOpCode aOpCode) {
+		private uint GetStackCount(MethodInfo aMethod, LocalVariableInfo aField)
-      throw new NotImplementedException();
+		{
+			var xSize = GetFieldStorageSize(aField.LocalType);
+			var xResult = xSize / 4;
+			if (xSize % 4 == 0)
+			{
+				xResult++;
+			}
+			return xResult;
 		}
 
+		private uint GetEBPOffsetForLocal(MethodInfo aMethod, OpVar aOp)
+		{
+			var xBody = aMethod.MethodBase.GetMethodBody();
+			uint xOffset = 0;
+			foreach (var xField in xBody.LocalVariables)
+			{
+				xOffset += GetStackCount(aMethod, xField);
+			}
+			return xOffset;
+		}
+
+		public override void Execute(MethodInfo aMethod, ILOpCode aOpCode)
+		{
+			var xField = aOpCode as ILOpCodes.OpVar;
+			var xFieldInfo = aMethod.MethodBase.GetMethodBody().LocalVariables[xField.Value];
+			var xEBPOffset = GetEBPOffsetForLocal(aMethod, xField);
+			if (!xFieldInfo.LocalType.IsValueType)
+			{
+				new CPUx86.Push { DestinationReg = CPUx86.Registers.EBP, DestinationIsIndirect = true, DestinationDisplacement =(int) xEBPOffset };
+				new CPUx86.Call { DestinationLabel = MethodInfoLabelGenerator.GenerateLabelName(GCImplementationRefs.DecRefCountRef) };
+			}
+			for (int i = (int)GetStackCount(aMethod, xFieldInfo) - 1; i >= 0; i--)
+			{
+				new CPUx86.Pop { DestinationReg = CPUx86.Registers.EAX }; ;
+				new CPUx86.Move { DestinationReg = CPUx86.Registers.EBP, DestinationIsIndirect = true, DestinationDisplacement =(int)( xEBPOffset + (i * 4)), SourceReg = CPUx86.Registers.EAX };
+			}
+			// no need to inc again, items on the transient stack are also counted
+			Assembler.Stack.Pop();
+		}
 
-		// using System;
-		// using System.Linq;
-		// using Indy.IL2CPU.Assembler;
-		// 
-		// 
-		// using CPUx86 = Indy.IL2CPU.Assembler.X86;
-		// 
-		// namespace Indy.IL2CPU.IL.X86 {
-		// 	[OpCode(OpCodeEnum.Stloc)]
-		// 	public class Stloc: Op {
 		// 		private bool mNeedsGC = false;
 		// 		private MethodInformation.Variable mLocal;
 		// 		private string mBaseLabel;

source2/IL2PCU/Cosmos.IL2CPU.X86/ILOp.cs

@@ -15,5 +15,10 @@ namespace Cosmos.IL2CPU.X86
         {
             Assembler = ( Assembler )aAsmblr;
         }
+
+		protected string GetLabel(MethodInfo aMethod, ILOpCode aOpCode)
+		{
+			return MethodInfoLabelGenerator.GenerateLabelName(aMethod.MethodBase) + "__DOT__" + aOpCode.Position.ToString("X8").ToUpper();
+		}
     }
 }

source2/IL2PCU/Cosmos.IL2CPU/Cosmos.IL2CPU.csproj

@@ -76,6 +76,7 @@
     <Compile Include="ILReader.cs" />
     <Compile Include="Instruction.cs" />
     <Compile Include="Label.cs" />
+    <Compile Include="MethodAndTypeLabelsHolder.cs" />
     <Compile Include="MethodInfo.cs" />
     <Compile Include="MethodInfoLabelGenerator.cs" />
     <Compile Include="OpCodeAttribute.cs" />

source2/IL2PCU/Cosmos.IL2CPU/ILOp.cs

@@ -17,5 +17,80 @@ namespace Cosmos.IL2CPU
         // could be used for other things, profiling, analysis, reporting, etc
         public abstract void Execute( MethodInfo aMethod, ILOpCode aOpCode );
 
+		protected static uint GetFieldStorageSize(Type aType)
+		{
+			if (aType.FullName == "System.Void")
+			{
+				return 0;
+			}
+			else if ((!aType.IsValueType && aType.IsClass) || aType.IsInterface)
+			{
+				return 4;
+			}
+			switch (aType.FullName)
+			{
+				case "System.Char":
+					return 2;
+				case "System.Byte":
+				case "System.SByte":
+					return 1;
+				case "System.UInt16":
+				case "System.Int16":
+					return 2;
+				case "System.UInt32":
+				case "System.Int32":
+					return 4;
+				case "System.UInt64":
+				case "System.Int64":
+					return 8;
+				//TODO: for now hardcode IntPtr and UIntPtr to be 32-bit
+				case "System.UIntPtr":
+				case "System.IntPtr":
+					return 4;
+				case "System.Boolean":
+					return 1;
+				case "System.Single":
+					return 4;
+				case "System.Double":
+					return 8;
+				case "System.Decimal":
+					return 16;
+				case "System.Guid":
+					return 16;
+				case "System.Enum":
+					return 4;
+				case "System.DateTime":
+					return 8;
+			}
+			if (aType.FullName != null && aType.FullName.EndsWith("*"))
+			{
+				// pointer
+				return 4;
+			}
+			// array
+			//TypeSpecification xTypeSpec = aType as TypeSpecification;
+			//if (xTypeSpec != null) {
+			//    return 4;
+			//}
+			if (aType.IsEnum)
+			{
+				return GetFieldStorageSize(aType.GetField("value__").FieldType);
+			}
+			if (aType.IsValueType)
+			{
+				var xSla = aType.StructLayoutAttribute;
+				if (xSla != null)
+				{
+					if (xSla.Size > 0)
+					{
+						return (uint)xSla.Size;
+					}
+				}
+			}
+			uint xResult;
+			//GetTypeFieldInfo(aType,  out xResult);
+			throw new Exception("TODO");
+			return xResult;
+		}
     }
 }

source2/IL2PCU/Cosmos.IL2CPU/MethodAndTypeLabelsHolder.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Cosmos.IL2CPU
+{
+	public static class MethodAndTypeLabelsHolder
+	{
+		//public static readonly uint 
+	}
+}

source2/IL2PCU/Cosmos.IL2CPU/StackContents.cs

@@ -80,5 +80,13 @@ namespace Cosmos.IL2CPU {
       mStack.Push(new Item(aSize, aIsNumber, aIsFloat, aIsSigned));
     }
 
+	public IEnumerator<Item> GetEnumerator()
+	{
+		foreach (var item in mStack)
+		{
+			yield return item;
+		}
+	}
+
  }
 }