Beispiel #1
0
        /// <summary>
        /// Gets the name of the operand as used in the manuals.
        /// </summary>
        /// <param name="operand">The operand.</param>
        /// <returns>The operand name.</returns>
        string GetOperandManualName(X86OperandSpec operand)
        {
            switch (operand.Type)
            {
            case X86OperandType.RegisterOperand:
                return("reg" + operand.Size.GetBitCount());

            case X86OperandType.FixedRegister:
                return(Enum.GetName(typeof(Register), operand.FixedRegister).ToUpperInvariant());

            case X86OperandType.Immediate:
                return("imm" + operand.Size.GetBitCount());

            case X86OperandType.MemoryOperand:
                return("mem" + operand.Size.GetBitCount());

            case X86OperandType.MemoryOffset:
                return("moffset" + operand.Size.GetBitCount());

            case X86OperandType.FarPointer:
                return("pntr16:" + operand.Size.GetBitCount());

            case X86OperandType.RegisterOrMemoryOperand:
                return("reg/mem" + operand.Size.GetBitCount());

            case X86OperandType.RelativeOffset:
                return("rel" + operand.Size.GetBitCount() + "off");

            default:
                throw new NotSupportedException("The operand type is not supported.");
            }
        }
Beispiel #2
0
        /// <summary>
        /// Writes the operand descriptor.
        /// </summary>
        /// <param name="operand">The operand specification.</param>
        /// <param name="writer">The <see cref="TextWriter"/> to write to.</param>
        void WriteOperandDescriptor(X86OperandSpec operand, TextWriter writer)
        {
            string encodingStr = string.Empty;

            if (operand.Encoding != X86OperandEncoding.Default)
            {
                encodingStr = ", OperandEncoding." + Enum.GetName(typeof(X86OperandEncoding), operand.Encoding);
            }

            switch (operand.Type)
            {
            case X86OperandType.RegisterOperand:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose{0}Bit" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            case X86OperandType.FixedRegister:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(Register.{0})",
                             Enum.GetName(typeof(Register), operand.FixedRegister).ToUpperInvariant());
                break;

            case X86OperandType.Immediate:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.Immediate, DataSize.Bit{0}" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            case X86OperandType.MemoryOperand:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.MemoryOperand, DataSize.Bit{0}" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            case X86OperandType.MemoryOffset:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.MemoryOffset, DataSize.Bit{0}" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            case X86OperandType.FarPointer:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.FarPointer, DataSize.Bit{0}" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            case X86OperandType.RegisterOrMemoryOperand:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose{0}Bit" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            case X86OperandType.RelativeOffset:
                writer.Write(T + T + T + T + T + "new OperandDescriptor(OperandType.RelativeOffset, DataSize.Bit{0}" + encodingStr + ")",
                             operand.Size.GetBitCount());
                break;

            default:
                throw new NotSupportedException("The operand type is not supported.");
            }
        }
Beispiel #3
0
        /// <summary>
        /// Gets the arguments for the specified operand.
        /// </summary>
        /// <param name="operand">The operand.</param>
        /// <param name="clsCompliant">Whether the resulting method is CLS compliant.</param>
        /// <returns>An array of tuples. Each tuple specifies the type of the argument and the
        /// implementation as an operand. The latter uses <c>{0}</c> in place of the argument name.</returns>
        IEnumerable <Tuple <X86OperandSpec, string, string> > GetOperandArguments(X86OperandSpec operand)
        {
            switch (operand.Type)
            {
            case X86OperandType.Immediate:
                if (operand.Size == DataSize.Bit8)
                {
                    return(new Tuple <X86OperandSpec, string, string>[] {
                        new Tuple <X86OperandSpec, string, string>(operand, "byte", "new Immediate({0}, DataSize.Bit8)"),
                        new Tuple <X86OperandSpec, string, string>(operand, "sbyte", "new Immediate({0}, DataSize.Bit8)"),
                    });
                }
                else if (operand.Size == DataSize.Bit16)
                {
                    return(new Tuple <X86OperandSpec, string, string>[] {
                        new Tuple <X86OperandSpec, string, string>(operand, "short", "new Immediate({0}, DataSize.Bit16)"),
                        new Tuple <X86OperandSpec, string, string>(operand, "ushort", "new Immediate({0}, DataSize.Bit16)"),
                    });
                }
                else if (operand.Size == DataSize.Bit32)
                {
                    return(new Tuple <X86OperandSpec, string, string>[] {
                        new Tuple <X86OperandSpec, string, string>(operand, "int", "new Immediate({0}, DataSize.Bit32)"),
                        new Tuple <X86OperandSpec, string, string>(operand, "uint", "new Immediate({0}, DataSize.Bit32)"),
                    });
                }
                else if (operand.Size == DataSize.Bit64)
                {
                    return(new Tuple <X86OperandSpec, string, string>[] {
                        new Tuple <X86OperandSpec, string, string>(operand, "long", "new Immediate({0}, DataSize.Bit64)"),
                        new Tuple <X86OperandSpec, string, string>(operand, "ulong", "new Immediate({0}, DataSize.Bit64)"),
                    });
                }
                else
                {
                    throw new NotSupportedException("The operand size is not supported.");
                }

            case X86OperandType.MemoryOperand:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "EffectiveAddress", "{0}"),
                });

            case X86OperandType.MemoryOffset:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "MemoryOffset", "{0}"),
                });

            case X86OperandType.FarPointer:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "FarPointer", "{0}"),
                    new Tuple <X86OperandSpec, string, string>(operand, "EffectiveAddress", "{0}"),
                });

            case X86OperandType.RegisterOrMemoryOperand:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "Register", "new RegisterOperand({0})"),
                    new Tuple <X86OperandSpec, string, string>(operand, "EffectiveAddress", "{0}"),
                });

            case X86OperandType.RelativeOffset:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "RelativeOffset", "{0}"),
                });

            case X86OperandType.RegisterOperand:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "Register", "new RegisterOperand({0})"),
                });

            case X86OperandType.FixedRegister:
                return(new Tuple <X86OperandSpec, string, string>[] {
                    new Tuple <X86OperandSpec, string, string>(operand, "Register", "new RegisterOperand({0})"),
                });

            //return Enumerable.Empty<Tuple<X86OperandSpec, String, String>>();
            default:
                throw new NotSupportedException("The operand type is not supported.");
            }
        }
Beispiel #4
0
        /// <inheritdoc />
        public override OperandSpec CreateOperandSpec(string type, object defaultValue)
        {
            var operandSpec = new X86OperandSpec();

            if (type.Equals("void"))
            {
                operandSpec.Type          = X86OperandType.FixedRegister;
                operandSpec.FixedRegister = ToRegister(defaultValue);
            }
            else
            {
                DataSize size;
                if (type.EndsWith("128"))
                {
                    size = DataSize.Bit128;
                    type = type.Substring(0, type.Length - 3);
                }
                else if (type.EndsWith("64"))
                {
                    size = DataSize.Bit64;
                    type = type.Substring(0, type.Length - 2);
                }
                else if (type.EndsWith("32"))
                {
                    size = DataSize.Bit32;
                    type = type.Substring(0, type.Length - 2);
                }
                else if (type.EndsWith("16"))
                {
                    size = DataSize.Bit16;
                    type = type.Substring(0, type.Length - 2);
                }
                else if (type.EndsWith("8"))
                {
                    size = DataSize.Bit8;
                    type = type.Substring(0, type.Length - 1);
                }
                else
                {
                    throw new ScriptException(string.Format("Malformatted type {0}", type));
                }
                operandSpec.Size = size;

                switch (type)
                {
                case "reg/mem":
                    operandSpec.Type = X86OperandType.RegisterOrMemoryOperand;
                    break;

                case "reg":
                    operandSpec.Type = X86OperandType.RegisterOperand;
                    break;

                case "moffset":
                    operandSpec.Type = X86OperandType.MemoryOffset;
                    break;

                case "imm":
                    operandSpec.Type = X86OperandType.Immediate;
                    break;

                case "mem":
                    operandSpec.Type = X86OperandType.MemoryOperand;
                    break;

                case "reloff":
                    operandSpec.Type = X86OperandType.RelativeOffset;
                    break;

                case "pntr16:":
                    operandSpec.Type = X86OperandType.FarPointer;
                    break;

                default:
                    throw new ScriptException(string.Format("Unknown operand type {0}", type));
                }
            }

            return(operandSpec);
        }