Пример #1
0
 public override CallingConvention?GetCallingConvention(string?ccName)
 {
     return(arch.GetCallingConvention(ccName));
 }
Пример #2
0
        public CallingConvention CreateCallingConverion(IProcessorArchitecture arch)
        {
            switch (arch.Name)
            {
            case "mips-be-32":
            case "mips-le-32":
            case "mips-be-64":
            case "mips-le-64":
                return(new MipsCallingConvention(arch)); //$ ccName?

            case "ppc-be-32":
            case "ppc-le-32":
                return(new PowerPcCallingConvention(arch));

            case "ppc-be-64":
            case "ppc-le-64":
                return(new PowerPc64CallingConvention(arch));

            case "sparc32":
            case "sparc64":
                return(new SparcCallingConvention(arch));

            case "x86-protected-32":
                if (this.ccX86 == null)
                {
                    var svc = services.RequireService <IPluginLoaderService>();
                    var t   = svc.GetType("Reko.Arch.X86.X86CallingConvention,Reko.Arch.X86");
                    this.ccX86 = (CallingConvention)Activator.CreateInstance(
                        t,
                        4,      // retAddressOnStack,
                        4,      // stackAlignment,
                        4,      // pointerSize,
                        true,   // callerCleanup,
                        false); // reverseArguments)
                }
                return(this.ccX86);

            case "x86-protected-64":
                return(new X86_64CallingConvention(arch));

            case "xtensa":
                return(new XtensaCallingConvention(arch));

            case "arm":
                return(new Arm32CallingConvention(arch));

            case "arm-64":
                // Documentation states to use the architecture-defined ABI.
                return(arch.GetCallingConvention("") !);

            case "m68k":
                return(new M68kCallingConvention(arch));

            case "avr8":
                return(new Avr8CallingConvention(arch));

            case "avr32":
                return(new Avr32CallingConvention(arch));

            case "msp430":
                return(new Msp430CallingConvention(arch));

            case "risc-v":
                if (this.ccRiscV == null)
                {
                    var t = Type.GetType("Reko.Arch.RiscV.RiscVCallingConvention,Reko.Arch.RiscV", true);
                    this.ccRiscV = (CallingConvention)Activator.CreateInstance(t, arch);
                }
                return(this.ccRiscV);

            case "superH-le":
            case "superH-be":
                return(new SuperHCallingConvention(arch));

            case "alpha":
                return(new AlphaCallingConvention(arch));

            case "zSeries":
                return(new zSeriesCallingConvention(arch));

            case "blackfin":
                return(new BlackfinCallingConvention(arch));

            case "hexagon":
                return(new HexagonCallingConvention(arch));

            case "ia64":
                return(new Ia64CallingConvention(arch));

            case "vax":
                return(new VaxCallingConvention(arch));

            case "nios2":
                return(new Nios2CallingConvention(arch));

            default:
                throw new NotImplementedException(string.Format("ELF calling convention for {0} not implemented yet.", arch.Description));
            }
        }