CreateProcedureSerializer() public abstract méthode

Creates a procedure serializer that understands the calling conventions used on this processor and environment
public abstract CreateProcedureSerializer ( ISerializedTypeVisitor typeLoader, string defaultConvention ) : Reko.Core.Serialization.ProcedureSerializer
typeLoader ISerializedTypeVisitor Used to resolve data types
defaultConvention string Default calling convention, if none specified.
Résultat Reko.Core.Serialization.ProcedureSerializer
Platform Class Documentation
Exemple #1
0
 public void LoadProcedure(Procedure_v1 sp)
 {
     try
     {
         var sser      = platform.CreateProcedureSerializer(this, this.defaultConvention);
         var signature = sser.Deserialize(sp.Signature, platform.Architecture.CreateFrame());
         signaturesByName[sp.Name] = signature;    //$BUGBUG: catch dupes?
         if (sp.Ordinal != Procedure_v1.NoOrdinal)
         {
             servicesByOrdinal[sp.Ordinal] = new SystemService {
                 Name      = sp.Name,
                 Signature = signature,
             };
         }
     }
     catch (Exception ex)
     {
         Debug.Print("An error occurred when loading the signature of procedure {0}.", sp.Name);
         throw new ApplicationException(
                   string.Format("An error occurred when loading the signature of procedure {0}.", sp.Name),
                   ex);
     }
 }
Exemple #2
0
        public ProcedureSerializer CreateProcedureSerializer()
        {
            var typeLoader = new TypeLibraryDeserializer(Platform, true, EnvironmentMetadata.Clone());

            return(Platform.CreateProcedureSerializer(typeLoader, Platform.DefaultCallingConvention));
        }
Exemple #3
0
 public SystemService Build(Platform platform)
 {
     SystemService svc = new SystemService();
     svc.Name = Name;
     svc.SyscallInfo = new SyscallInfo();
     svc.SyscallInfo.Vector = Convert.ToInt32(SyscallInfo.Vector, 16);
     if (SyscallInfo.RegisterValues != null)
     {
         svc.SyscallInfo.RegisterValues = new RegValue[SyscallInfo.RegisterValues.Length];
         for (int i = 0; i < SyscallInfo.RegisterValues.Length; ++i)
         {
             svc.SyscallInfo.RegisterValues[i] = new RegValue
             {
                 Register = platform.Architecture.GetRegister(SyscallInfo.RegisterValues[i].Register),
                 Value = Convert.ToInt32(SyscallInfo.RegisterValues[i].Value, 16),
             };
         }
     }
     else
     {
         svc.SyscallInfo.RegisterValues = new RegValue[0];
     }
     TypeLibraryLoader loader = new TypeLibraryLoader(platform, true);
     var sser = platform.CreateProcedureSerializer(loader, "stdapi");
     svc.Signature = sser.Deserialize(Signature, platform.Architecture.CreateFrame());
     svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance;
     return svc;
 }
Exemple #4
0
 /// <summary>
 /// Guesses the signature of a procedure based on its name.
 /// </summary>
 /// <param name="fnName"></param>
 /// <param name="loader"></param>
 /// <param name="arch"></param>
 /// <returns></returns>
 public static ProcedureSignature SignatureFromName(string fnName, TypeLibraryLoader loader, Platform platform)
 {
     int argBytes;
     if (fnName[0] == '_')
     {
         // Win32 prefixes cdecl and stdcall functions with '_'. Stdcalls will have @<nn>
         // where <nn> is the number of bytes pushed on the stack. If 0 bytes are pushed
         // the result is indistinguishable from the corresponding cdecl call, which is OK.
         int lastAt = fnName.LastIndexOf('@');
         if (lastAt < 0)
             return CdeclSignature(fnName.Substring(1), platform.Architecture);
         string name = fnName.Substring(1, lastAt - 1);
         if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes))
             return CdeclSignature(name, platform.Architecture);
         else
             return StdcallSignature(name, argBytes, platform.Architecture);
     }
     else if (fnName[0] == '@')
     {
         // Win32 prefixes fastcall functions with '@'.
         int lastAt = fnName.LastIndexOf('@');
         if (lastAt <= 0)
             return CdeclSignature(fnName.Substring(1), platform.Architecture);
         string name = fnName.Substring(1, lastAt - 1);
         if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes))
             return CdeclSignature(name, platform.Architecture);
         else
             return FastcallSignature(name, argBytes, platform.Architecture);
     }
     else if (fnName[0] == '?')
     {
         // Microsoft-mangled signatures begin with '?'
         var pmnp = new MsMangledNameParser(fnName);
         StructField_v1 field = null;
         try
         {
             field = pmnp.Parse();
         }
         catch (Exception ex)
         {
             Debug.Print("*** Error parsing {0}. {1}", fnName, ex.Message);
             pmnp.ToString();
             return null;
         }
         var sproc = field.Type as SerializedSignature;
         if (sproc != null)
         {
             var sser = platform.CreateProcedureSerializer(loader, "__cdecl");
             return sser.Deserialize(sproc, platform.Architecture.CreateFrame());    //$BUGBUG: catch dupes?
         }
     }
     return null;
 }