internal void MapParameters(bool reduceByRef) {
            if (reduceByRef) {
                _returnArgs = new List<int>();
                if (CompilerHelpers.GetReturnType(_method) != typeof(void)) {
                    _returnArgs.Add(-1);
                }
            }

            BitArray specialParameters = _resolver.MapSpecialParameters(this);

            if (_instanceBuilder == null) {
                _instanceBuilder = new NullArgBuilder();
            }

            for (int infoIndex = 0; infoIndex < _parameterInfos.Length; infoIndex++) {
                if (!IsSpecialParameter(specialParameters, infoIndex)) {
                    if (reduceByRef) {
                        MapParameterReduceByRef(_parameterInfos[infoIndex]);
                    } else {
                        MapParameter(_parameterInfos[infoIndex]);
                    }
                }
            }

            _returnBuilder = MakeReturnBuilder(specialParameters);
        }

        public KeywordArgBuilder(ArgBuilder builder, int kwArgCount, int kwArgIndex) 
            : base(builder.ParameterInfo) {

            Debug.Assert(BuilderExpectsSingleParameter(builder));
            _builder = builder;

            Debug.Assert(kwArgIndex < kwArgCount);
            _kwArgCount = kwArgCount;
            _kwArgIndex = kwArgIndex;
        }

        internal MethodTarget(MethodBinder binder, MethodBase method, int parameterCount, ArgBuilder instanceBuilder, IList<ArgBuilder> argBuilders, ReturnBuilder returnBuilder) {
            this._binder = binder;
            this._method = method;
            this._parameterCount = parameterCount;
            this._instanceBuilder = instanceBuilder;
            this._argBuilders = argBuilders;
            this._returnBuilder = returnBuilder;

            //argBuilders.TrimExcess();
        }

        internal MethodCandidate(OverloadResolver resolver, MethodBase method, List<ParameterWrapper> parameters, ParameterWrapper paramsDict,
            ReturnBuilder returnBuilder, ArgBuilder instanceBuilder, IList<ArgBuilder> argBuilders) {

            Assert.NotNull(resolver, method, instanceBuilder, returnBuilder);
            Assert.NotNullItems(parameters);
            Assert.NotNullItems(argBuilders);

            _resolver = resolver;
            _method = method;
            _instanceBuilder = instanceBuilder;
            _argBuilders = argBuilders;
            _returnBuilder = returnBuilder;
            _parameters = parameters;
            _paramsDict = paramsDict;

            _paramsArrayIndex = ParameterWrapper.IndexOfParamsArray(parameters);

            parameters.TrimExcess();
        }

        /// <summary>
        /// Starg
        /// </summary>
        /// <param name="arg"></param>
        public void Starg(ArgBuilder arg)
        {
            Check.Require(arg, "arg");

            this.Starg(arg.Index);
        }

        /// <summary>
        /// LdargAddress ���ز�����ַ��ILû�����ָ������ݲ��������ͷֱ���ò�ͬ��ILָ�
        /// ������Ϊֵ����ʱ��ͨ������Ldargaָ����ز�����ַ
        /// ���β�Ϊֵ����ʱ��ֱ�ӵ���Ldarg���ز���
        /// </summary>
        /// <param name="argBuilder"></param>
        public void LdargAddress(ArgBuilder argBuilder)
        {
            Check.Require(argBuilder, "argBuilder");

            if (argBuilder.ArgType.IsValueType)
            {
                this.Ldarga(argBuilder);
            }
            else
            {
                this.Ldarg(argBuilder);
            }
        }

        /// <summary>
        /// Ldarga ���� Ldarga(int) ����
        /// </summary>
        /// <param name="argBuilder"></param>
        public void Ldarga(ArgBuilder argBuilder)
        {
            Check.Require(argBuilder, "argBuilder");

            this.Ldarga(argBuilder.Index);
        }

            void InitArgs(Type objType)
            {
                xmlWriterArg = ilg.GetArg(0);
                contextArg = ilg.GetArg(2);
                dataContractArg = ilg.GetArg(3);

                objectLocal = ilg.DeclareLocal(objType, "objSerialized");
                ArgBuilder objectArg = ilg.GetArg(1);
                ilg.Load(objectArg);

                // Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
                // DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
                // on DateTimeOffset; which does not work in partial trust.

                if (objType == Globals.TypeOfDateTimeOffsetAdapter)
                {
                    ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
                    ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
                }
                else
                {
                    ilg.ConvertValue(objectArg.ArgType, objType);
                }
                ilg.Stloc(objectLocal);
            }

 void IsStartElement(ArgBuilder nameArg, ArgBuilder nsArg)
 {
     ilg.Call(xmlReaderArg, XmlFormatGeneratorStatics.IsStartElementMethod2, nameArg, nsArg);
 }

 internal void Ldarg(ArgBuilder arg) {
     Ldarg(arg.Index);
 }

 private void InitArgs(Type objType)
 {
     this.xmlWriterArg = this.ilg.GetArg(0);
     this.contextArg = this.ilg.GetArg(2);
     this.dataContractArg = this.ilg.GetArg(3);
     this.objectLocal = this.ilg.DeclareLocal(objType, "objSerialized");
     ArgBuilder arg = this.ilg.GetArg(1);
     this.ilg.Load(arg);
     if (objType == Globals.TypeOfDateTimeOffsetAdapter)
     {
         this.ilg.ConvertValue(arg.ArgType, Globals.TypeOfDateTimeOffset);
         this.ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
     }
     else
     {
         this.ilg.ConvertValue(arg.ArgType, objType);
     }
     this.ilg.Stloc(this.objectLocal);
 }

            private void InitArgs(Type objType)
            {
                _xmlWriterArg = _ilg.GetArg(0);
                _contextArg = _ilg.GetArg(2);
                _dataContractArg = _ilg.GetArg(3);

                _objectLocal = _ilg.DeclareLocal(objType, "objSerialized");
                ArgBuilder objectArg = _ilg.GetArg(1);
                _ilg.Load(objectArg);

                // Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
                // DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
                // on DateTimeOffset; which does not work in partial trust.

                if (objType == Globals.TypeOfDateTimeOffsetAdapter)
                {
                    _ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
                    _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
                }
                //Copy the KeyValuePair<K,T> to a KeyValuePairAdapter<K,T>. 
                else if (objType.GetTypeInfo().IsGenericType && objType.GetGenericTypeDefinition() == Globals.TypeOfKeyValuePairAdapter)
                {
                    ClassDataContract dc = (ClassDataContract)DataContract.GetDataContract(objType);
                    _ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfKeyValuePair.MakeGenericType(dc.KeyValuePairGenericArguments));
                    _ilg.New(dc.KeyValuePairAdapterConstructorInfo);
                }
                else
                {
                    _ilg.ConvertValue(objectArg.ArgType, objType);
                }
                _ilg.Stloc(_objectLocal);
            }

 /// <summary>
 /// The underlying builder should expect a single parameter as KeywordArgBuilder is responsible
 /// for calculating the correct parameter to use
 /// </summary>
 /// <param name="builder"></param>
 internal static bool BuilderExpectsSingleParameter(ArgBuilder builder) {
     return (((SimpleArgBuilder)builder).Index == 0);
 }

 internal VariantBuilder(VarEnum targetComType, ArgBuilder builder) {
     _targetComType = targetComType;
     _argBuilder = builder;
 }

 internal void Ldarga(ArgBuilder argBuilder) {
     Ldarga(argBuilder.Index);
 }

 void InitILGeneration(Type[] argTypes, string[] argNames, bool isStatic) {
     this.methodEndLabel = ilGen.DefineLabel();
     this.retLabel = ilGen.DefineLabel();
     this.blockStack = new Stack();
     this.whileStack = new Stack();
     this.currentScope = new LocalScope();
     this.freeLocals = new Dictionary<Tuple<Type, string>, Queue<LocalBuilder>>(); 
     this.argList = new Dictionary<string, ArgBuilder>();
     // this ptr is arg 0 for non static, assuming ref type (not value type) 
     if (!isStatic)
         argList.Add("this", new ArgBuilder("this", 0, this.typeBuilder.BaseType));
     for (int i = 0; i < argTypes.Length; i++) {
         ArgBuilder arg = new ArgBuilder(argNames[i], argList.Count, argTypes[i]);
         argList.Add(arg.Name, arg);
         this.methodBuilder.DefineParameter(arg.Index, ParameterAttributes.None, arg.Name);
     }
 }

 internal void LdargAddress(ArgBuilder argBuilder) {
     if (argBuilder.ArgType.IsValueType)
         Ldarga(argBuilder);
     else
         Ldarg(argBuilder);
 }

 internal void LdargAddress(ArgBuilder argBuilder)
 {
     if (argBuilder.ArgType.IsValueType)
     {
         this.Ldarga(argBuilder);
     }
     else
     {
         this.Ldarg(argBuilder);
     }
 }

 internal void Starg(ArgBuilder arg)
 {
     Starg(arg.Index);
 }

 void LoadInputParametersIntoLocals(ParameterInfo[] parameters, LocalBuilder[] parameterLocals, ArgBuilder inputParametersArg, out int inputParameterCount)
 {
     inputParameterCount = 0;
     for (int i = 0; i < parameterLocals.Length; i++)
     {
         if (ServiceReflector.FlowsIn(parameters[i]))
         {
             Type parameterType = parameterLocals[i].LocalType;
             ilg.LoadArrayElement(inputParametersArg, inputParameterCount);
             if (!parameterType.IsValueType)
             {
                 ilg.ConvertValue(TypeOfObject, parameterType);
                 ilg.Store(parameterLocals[i]);
             }
             else
             {
                 ilg.Dup();
                 ilg.If();
                 ilg.ConvertValue(TypeOfObject, parameterType);
                 ilg.Store(parameterLocals[i]);
                 ilg.Else();
                 ilg.Pop();
                 ilg.LoadZeroValueIntoLocal(parameterType, parameterLocals[i]);
                 ilg.EndIf();
             }
             inputParameterCount++;
         }
     }
 }