Add abi offset

src/Neo.Compiler.MSIL/FuncExport.cs

@@ -81,43 +81,30 @@ 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;
 
             List<string> names = new List<string>();
             foreach (var function in module.mapMethods)
             {
+                var offset = function.Value.funcaddr;
+                if (offset == -1) continue;
                 var mm = function.Value;
                 if (mm.inSmartContract == false)
                     continue;
                 if (mm.isPublic == false)
                     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);
+                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

@@ -14,6 +14,8 @@ public class NefInstruction : INefItem
 
         public OpCode OpCode { get; private set; }
         public uint Size => (1 + DataPrefixSize + DataSize);
+        public bool IsMethodEntry = false;
+        public string MethodName = null;
 
         private uint DataPrefixSize => GetOperandPrefixSize(OpCode);
         private uint DataSize => DataPrefixSize > 0 ? (uint)(Data?.Length ?? 0) : GetOperandSize(OpCode);

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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 
 namespace Neo.Compiler.Optimizer
@@ -10,9 +11,9 @@ public static class NefOptimizeTool
         /// </summary>
         /// <param name="script">Script</param>
         /// <returns>Optimized script</returns>
-        public static byte[] Optimize(byte[] script)
+        public static byte[] Optimize(byte[] script, NeoModule module = null)
         {
-            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 }, module);
         }
 
         /// <summary>
@@ -25,7 +26,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, NeoModule module = null)
         {
             var optimizer = new NefOptimizer();
 
@@ -41,18 +42,34 @@ public static byte[] Optimize(byte[] script, OptimizeParserType[] parserTypes)
                 optimizer.AddOptimizeParser(parser);
             }
 
+            //find method entry
+            Dictionary<string, int> methodEntry = new Dictionary<string, int>();
+            if (module != null)
+            {
+                foreach (var function in module.mapMethods)
+                {
+                    var mm = function.Value;
+                    if (mm.inSmartContract == false || mm.isPublic == false)
+                        continue;
+                    if (methodEntry.ContainsKey(function.Value.displayName))
+                        throw new Exception("not allow same name functions");
+
+                    methodEntry.Add(function.Value.displayName, function.Value.funcaddr);
+                }
+            }
+
             //step01 Load
             using (var ms = new MemoryStream(script))
             {
-                optimizer.LoadNef(ms);
+                optimizer.LoadNef(ms, methodEntry);
             }
             //step02 doOptimize
             optimizer.Optimize();
 
             //step03 link
             using (var ms = new MemoryStream())
             {
-                optimizer.LinkNef(ms);
+                optimizer.LinkNef(ms, module);
                 var bytes = ms.ToArray();
                 return bytes;
             }

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

@@ -1,5 +1,7 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 
 namespace Neo.Compiler.Optimizer
 {
@@ -16,13 +18,13 @@ public class NefOptimizer
         /// Constructor
         /// </summary>
         /// <param name="script">Script</param>
-        public NefOptimizer(byte[] script = null)
+        public NefOptimizer(byte[] script = null, Dictionary<string, int> methodEntry = null)
         {
             if (script != null)
             {
                 using (var ms = new MemoryStream(script))
                 {
-                    LoadNef(ms);
+                    LoadNef(ms, methodEntry);
                 }
             }
         }
@@ -57,7 +59,7 @@ public void Optimize()
         /// Step01 Load
         /// </summary>
         /// <param name="stream">Stream</param>
-        public void LoadNef(Stream stream)
+        public void LoadNef(Stream stream, Dictionary<string, int> methodEntry = null)
         {
             //read all Instruction to listInst
             var listInst = new List<NefInstruction>();
@@ -99,6 +101,13 @@ public void LoadNef(Stream stream)
                     Items.Add(mapLabel[curOffset]);
                 }
                 Items.Add(instruction);
+
+                if (methodEntry.ContainsValue(instruction.Offset))
+                {
+                    var methodName = methodEntry.FirstOrDefault(q => q.Value == instruction.Offset).Key;
+                    instruction.IsMethodEntry = true;
+                    instruction.MethodName = methodName;
+                }
             }
         }
 
@@ -140,17 +149,38 @@ void RefillAddr()
             }
         }
 
-        public void LinkNef(Stream stream)
+        public void LinkNef(Stream stream, NeoModule module)
         {
             //Recalc Address
             //collection Labels and Resort Offset
             RefillAddr();
 
             //and Link
+            //and find method entry offset
+            Dictionary<string, int> methodEntry = new Dictionary<string, int>();
             foreach (var inst in this.Items)
             {
                 if (inst is NefInstruction i)
+                {
                     i.WriteTo(stream);
+                    if (i.IsMethodEntry == true)
+                        methodEntry.TryAdd(i.MethodName, i.Offset);
+                }
+            }
+
+            if (module != null)
+            {
+                foreach (var function in module.mapMethods)
+                {
+                    if (methodEntry.ContainsKey(function.Value.displayName))
+                    {
+                        function.Value.funcaddr = methodEntry[function.Value.displayName];
+                    }
+                    else
+                    {
+                        function.Value.funcaddr = -1;
+                    }
+                }
             }
         }
     }

src/Neo.Compiler.MSIL/Program.cs

@@ -165,7 +165,7 @@ public static int Compile(Options options)
 
                 if (options.Optimize)
                 {
-                    var optimize = NefOptimizeTool.Optimize(bytes);
+                    var optimize = NefOptimizeTool.Optimize(bytes, module);
                     log.Log("optimization succ " + (((bytes.Length / (optimize.Length + 0.0)) * 100.0) - 100).ToString("0.00 '%'"));
                     bytes = optimize;
                 }