Add abi offset

src/Neo.Compiler.MSIL/FuncExport.cs

@@ -63,7 +63,7 @@ static string ConvType(string _type)
             return "Unknown:" + _type;
         }
 
-        public static MyJson.JsonNode_Object Export(NeoModule module, byte[] script)
+        public static MyJson.JsonNode_Object Export(NeoModule module, byte[] script, Dictionary<int, int> addrConvTable)
         {
             var sha256 = System.Security.Cryptography.SHA256.Create();
             byte[] hash256 = sha256.ComputeHash(script);
@@ -81,14 +81,6 @@ public static MyJson.JsonNode_Object Export(NeoModule module, byte[] script)
             }
             outjson.SetDictValue("hash", sb.ToString());
 
-            //entrypoint
-            var entryPoint = "main";
-            var mainmethod = module.mapMethods[module.mainMethod];
-            if (mainmethod != null)
-            {
-                entryPoint = mainmethod.displayName;
-            }
-
             //functions
             var methods = new MyJson.JsonNode_Array();
             outjson["methods"] = methods;
@@ -103,21 +95,15 @@ public static MyJson.JsonNode_Object Export(NeoModule module, byte[] script)
                     continue;
 
                 var funcsign = new MyJson.JsonNode_Object();
-                if (function.Value.displayName == entryPoint)
-                {
-                    // This is the entryPoint
-                    outjson.SetDictValue("entryPoint", funcsign);
-                }
-                else
-                {
-                    methods.Add(funcsign);
-                }
+                methods.Add(funcsign);
                 funcsign.SetDictValue("name", function.Value.displayName);
                 if (names.Contains(function.Value.displayName))
                 {
                     throw new Exception("abi not allow same name functions");
                 }
                 names.Add(function.Value.displayName);
+                var offset = addrConvTable?[function.Value.funcaddr] ?? function.Value.funcaddr;
+                funcsign.SetDictValue("offset", offset.ToString());
                 MyJson.JsonNode_Array funcparams = new MyJson.JsonNode_Array();
                 funcsign["parameters"] = funcparams;
                 if (mm.paramtypes != null)

src/Neo.Compiler.MSIL/MSIL/Converter.cs

@@ -160,7 +160,7 @@ public NeoModule Convert(ILModule _in, ConvOption option = null)
                             if (l.Value == m)
                             {
                                 if (mainmethod != "")
-                                    throw new Exception("Have too mush EntryPoint,Check it.");
+                                    throw new Exception("Have too much EntryPoint,Check it.");
                                 mainmethod = key;
                             }
                         }

src/Neo.Compiler.MSIL/Optimizer/NefInstruction.cs

@@ -19,6 +19,7 @@ public class NefInstruction : INefItem
         private uint DataSize => DataPrefixSize > 0 ? (uint)(Data?.Length ?? 0) : GetOperandSize(OpCode);
 
         public byte[] Data { get; private set; }
+        public int OffsetInit { get; private set; }
         public int Offset { get; private set; }
         public string[] Labels { get; private set; }
 
@@ -46,10 +47,11 @@ static NefInstruction()
             }
         }
 
-        public NefInstruction(OpCode opCode, byte[] data = null, int offset = -1)
+        public NefInstruction(OpCode opCode, byte[] data, int offset)
         {
             SetOpCode(opCode);
             SetData(data);
+            OffsetInit = offset;
             SetOffset(offset);
         }
 

src/Neo.Compiler.MSIL/Optimizer/NefOptimizeTool.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 
 namespace Neo.Compiler.Optimizer
@@ -12,7 +13,19 @@ public static class NefOptimizeTool
         /// <returns>Optimized script</returns>
         public static byte[] Optimize(byte[] script)
         {
-            return Optimize(script, new OptimizeParserType[] { OptimizeParserType.DELETE_DEAD_CODDE, OptimizeParserType.USE_SHORT_ADDRESS });
+            return Optimize(script, new OptimizeParserType[] { OptimizeParserType.DELETE_DEAD_CODDE, OptimizeParserType.USE_SHORT_ADDRESS }
+            , out _);
+        }
+
+        public static byte[] Optimize(byte[] script, out Dictionary<int, int> addrConvertTable)
+        {
+            return Optimize(script, new OptimizeParserType[] { OptimizeParserType.DELETE_DEAD_CODDE, OptimizeParserType.USE_SHORT_ADDRESS }
+            , out addrConvertTable);
+        }
+
+        public static byte[] Optimize(byte[] script, OptimizeParserType[] parserTypes)
+        {
+            return Optimize(script, parserTypes, out _);
         }
 
         /// <summary>
@@ -25,7 +38,7 @@ public static byte[] Optimize(byte[] script)
         /// <para> DELETE_NOP -- delete nop parser</para>
         /// <para> DELETE_USELESS_JMP -- delete useless jmp parser, eg: JPM 2</para></param>
         /// <returns>Optimized script</returns>
-        public static byte[] Optimize(byte[] script, OptimizeParserType[] parserTypes)
+        public static byte[] Optimize(byte[] script, OptimizeParserType[] parserTypes, out Dictionary<int, int> addrConvertTable)
         {
             var optimizer = new NefOptimizer();
 
@@ -53,6 +66,7 @@ public static byte[] Optimize(byte[] script, OptimizeParserType[] parserTypes)
             using (var ms = new MemoryStream())
             {
                 optimizer.LinkNef(ms);
+                addrConvertTable = optimizer.GetAddrConvertTable();
                 var bytes = ms.ToArray();
                 return bytes;
             }

src/Neo.Compiler.MSIL/Optimizer/NefOptimizer.cs

@@ -27,6 +27,19 @@ public NefOptimizer(byte[] script = null)
             }
         }
 
+        public Dictionary<int, int> GetAddrConvertTable()
+        {
+            var addrConvertTable = new Dictionary<int, int>();
+            foreach (var item in Items)
+            {
+                if (item is NefInstruction inst)
+                {
+                    addrConvertTable[inst.OffsetInit] = inst.Offset;
+                }
+            }
+            return addrConvertTable;
+        }
+
         public void AddOptimizeParser(IOptimizeParser function)
         {
             OptimizeFunctions.Add(function);
@@ -150,7 +163,9 @@ public void LinkNef(Stream stream)
             foreach (var inst in this.Items)
             {
                 if (inst is NefInstruction i)
+                {
                     i.WriteTo(stream);
+                }
             }
         }
     }

src/Neo.Compiler.MSIL/Program.cs

@@ -162,17 +162,23 @@ public static int Compile(Options options)
                 module = conv.Convert(mod, option);
                 bytes = module.Build();
                 log.Log("convert succ");
-
+                Dictionary<int, int> addrConvTable = null;
                 if (options.Optimize)
                 {
-                    var optimize = NefOptimizeTool.Optimize(bytes);
+                    var optimize = NefOptimizeTool.Optimize(bytes, out addrConvTable);
                     log.Log("optimization succ " + (((bytes.Length / (optimize.Length + 0.0)) * 100.0) - 100).ToString("0.00 '%'"));
+                    foreach (var func in module.mapMethods)
+                    {
+                        int srcaddr = func.Value.funcaddr;
+                        int opaddr = addrConvTable[srcaddr];
+                        log.Log("func addr from " + srcaddr + "=>" + opaddr);
+                    }
                     bytes = optimize;
                 }
 
                 try
                 {
-                    var outjson = vmtool.FuncExport.Export(module, bytes);
+                    var outjson = vmtool.FuncExport.Export(module, bytes, addrConvTable);
                     StringBuilder sb = new StringBuilder();
                     outjson.ConvertToStringWithFormat(sb, 0);
                     jsonstr = sb.ToString();

tests/Neo.Compiler.MSIL.UnitTests/TestClasses/Contract_ABIOffset.cs

@@ -0,0 +1,34 @@
+namespace Neo.Compiler.MSIL.UnitTests.TestClasses
+{
+    public class Contract_ABIOffset : SmartContract.Framework.SmartContract
+    {
+        public static void Main(string method, object[] args)
+        {
+            UnitTest_001();
+            UnitTest_002();
+            UnitTest_003();
+            UnitTest_004();
+        }
+        public static byte[] UnitTest_001()
+        {
+            var nb = new byte[] { 1, 2, 3, 4 };
+            return nb;
+        }
+        public static byte[] UnitTest_002()
+        {
+            var nb = new byte[] { 1, 2, 3, 4 };
+            return nb;
+        }
+        public static byte[] UnitTest_003()
+        {
+            var nb = new byte[] { 1, 2, 3, 4 };
+            return nb;
+        }
+        public static byte[] UnitTest_004()
+        {
+            var nb = new byte[] { 1, 2, 3, 4 };
+            return nb;
+        }
+
+    }
+}

tests/Neo.Compiler.MSIL.UnitTests/UnitTest_ABI_Offset.cs

@@ -0,0 +1,41 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Compiler.MSIL.UnitTests.Utils;
+using Neo.VM.Types;
+using System;
+
+namespace Neo.Compiler.MSIL.UnitTests
+{
+    [TestClass]
+    public class UnitTest_ABI_Offset
+    {
+        [TestMethod]
+        public void UnitTest_TestABIOffsetWithoutOptimizer()
+        {
+            var testengine = new TestEngine();
+            testengine.AddEntryScript("./TestClasses/Contract_ABIOffset.cs", true, false);
+            var abi = testengine.ScriptEntry.finialABI;
+
+            var methodsABI = abi["methods"].AsList();
+            Assert.AreEqual("0", methodsABI[0].GetDictItem("offset").ToString());
+            Assert.AreEqual("32", methodsABI[1].GetDictItem("offset").ToString());
+            Assert.AreEqual("39", methodsABI[2].GetDictItem("offset").ToString());
+            Assert.AreEqual("46", methodsABI[3].GetDictItem("offset").ToString());
+            Assert.AreEqual("53", methodsABI[4].GetDictItem("offset").ToString());
+        }
+
+        [TestMethod]
+        public void UnitTest_TestABIOffsetWithOptimizer()
+        {
+            var testengine = new TestEngine();
+            testengine.AddEntryScript("./TestClasses/Contract_ABIOffset.cs", true, true);
+            var abi = testengine.ScriptEntry.finialABI;
+
+            var methodsABI = abi["methods"].AsList();
+            Assert.AreEqual("0", methodsABI[0].GetDictItem("offset").ToString());
+            Assert.AreEqual("16", methodsABI[1].GetDictItem("offset").ToString());
+            Assert.AreEqual("23", methodsABI[2].GetDictItem("offset").ToString());
+            Assert.AreEqual("30", methodsABI[3].GetDictItem("offset").ToString());
+            Assert.AreEqual("37", methodsABI[4].GetDictItem("offset").ToString());
+        }
+    }
+}

tests/Neo.Compiler.MSIL.UnitTests/Utils/BuildScript.cs

@@ -12,6 +12,11 @@ public bool IsBuild
             get;
             private set;
         }
+        public bool UseOptimizer
+        {
+            get;
+            private set;
+        }
         public Exception Error
         {
             get;
@@ -44,6 +49,7 @@ public void Build(Stream fs, Stream fspdb, bool optimizer)
         {
             this.IsBuild = false;
             this.Error = null;
+            this.UseOptimizer = optimizer;
 
             var log = new DefLogger();
             this.modIL = new ILModule(log);
@@ -59,6 +65,7 @@ public void Build(Stream fs, Stream fspdb, bool optimizer)
             }
 
             converterIL = new ModuleConverter(log);
+            Dictionary<int, int> addrConvTable = null;
             ConvOption option = new ConvOption();
 #if NDEBUG
             try
@@ -69,7 +76,7 @@ public void Build(Stream fs, Stream fspdb, bool optimizer)
                 finalNEF = converterIL.outModule.Build();
                 if (optimizer)
                 {
-                    var opbytes = NefOptimizeTool.Optimize(finalNEF);
+                    var opbytes = NefOptimizeTool.Optimize(finalNEF, out addrConvTable);
                     float ratio = (opbytes.Length * 100.0f) / (float)finalNEF.Length;
                     log.Log("optimization ratio = " + ratio + "%");
                     finalNEF = opbytes;
@@ -86,7 +93,7 @@ public void Build(Stream fs, Stream fspdb, bool optimizer)
 #endif
             try
             {
-                finialABI = vmtool.FuncExport.Export(converterIL.outModule, finalNEF);
+                finialABI = vmtool.FuncExport.Export(converterIL.outModule, finalNEF, addrConvTable);
             }
             catch
             {

tests/Neo.Compiler.MSIL.UnitTests/Utils/TestEngine.cs

@@ -40,7 +40,9 @@ public TestEngine(TriggerType trigger = TriggerType.Application, IVerifiable ver
 
         public BuildScript Build(string filename, bool releaseMode = false, bool optimizer = true)
         {
-            if (scriptsAll.ContainsKey(filename) == false)
+            var contains = scriptsAll.ContainsKey(filename);
+
+            if (!contains || (contains && scriptsAll[filename].UseOptimizer != optimizer))
             {
                 scriptsAll[filename] = NeonTestTool.BuildScript(filename, releaseMode, optimizer);
             }