/// <summary>
 /// Gets an object representing the static data for RVA mapped fields from the PE image.
 /// </summary>
 public ObjectNode GetFieldRvaData(FieldDesc field)
 {
     if (field.GetType() == typeof(Internal.IL.Stubs.PInvokeLazyFixupField))
     {
         var pInvokeFixup = (Internal.IL.Stubs.PInvokeLazyFixupField)field;
         PInvokeMetadata metadata = pInvokeFixup.PInvokeMetadata;
         return NodeFactory.PInvokeMethodFixup(metadata.Module, metadata.Name);
     }
     else
     {
         // Use the typical field definition in case this is an instantiated generic type
         field = field.GetTypicalFieldDefinition();
         return NodeFactory.ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field),
             ((EcmaField)field).GetFieldRvaData(), NodeFactory.Target.PointerSize);
     }
 }

 public ILToken NewToken(FieldDesc value)
 {
     return NewToken(value, 0x0a000000);
 }

 /// <summary>
 /// Gets an object representing the static data for RVA mapped fields from the PE image.
 /// </summary>
 public object GetFieldRvaData(FieldDesc field)
 {
     return _nodeFactory.ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field),
         ((EcmaField)field).GetFieldRvaData(), _typeSystemContext.Target.PointerSize);
 }

 private void AppendFieldSignature(StringBuilder sb, FieldDesc field)
 {
     this.TypeNameFormatter.AppendNameWithValueClassPrefix(sb, field.FieldType);
     sb.Append(' ');
     AppendOwningType(sb, field.OwningType);
     sb.Append("::");
     sb.Append(field.Name);
 }

        protected override bool ComputeHasGCStaticBase(FieldDesc field)
        {
            Debug.Assert(field.IsStatic);

            TypeDesc fieldType = field.FieldType;
            if (fieldType.IsValueType)
                return ((DefType)fieldType).ContainsGCPointers;
            else
                return fieldType.IsGCPointer;

        }

        public string GetMangledFieldName(FieldDesc field)
        {
            string mangledName;
            if (_mangledFieldNames.TryGetValue(field, out mangledName))
                return mangledName;

            return ComputeMangledFieldName(field);
        }

 private TypeDesc GetFieldTypeOrPlaceholder(FieldDesc field)
 {
     try
     {
         return field.FieldType;
     }
     catch
     {
         // TODO: For now, catch errors due to missing dependencies
         return _compilation.TypeSystemContext.GetWellKnownType(WellKnownType.Boolean);
     }
 }

 public string GetCppFieldName(FieldDesc field)
 {
     return _compilation.NameMangler.GetMangledFieldName(field).ToString();
 }

 public RvaFieldData(Compilation compilation, FieldDesc field)
 {
     Debug.Assert(field.HasRva);
     Field = field;
     _compilation = compilation;
 }

 public bool GeneratesMetadata(FieldDesc fieldDef)
 {
     return GeneratesMetadata((MetadataType)fieldDef.OwningType);
 }

        public void AddField(FieldDesc field)
        {
            RegisteredField reg = GetRegisteredField(field);
            if (reg.IncludedInCompilation)
                return;
            reg.IncludedInCompilation = true;

            if (_options.IsCppCodeGen)
            {
                // Precreate name to ensure that all types referenced by signatures are present
                GetRegisteredType(field.OwningType);
                GetRegisteredType(field.FieldType);
            }
        }

        internal RegisteredField GetRegisteredField(FieldDesc field)
        {
            RegisteredField existingRegistration;
            if (_registeredFields.TryGetValue(field, out existingRegistration))
                return existingRegistration;

            RegisteredField registration = new RegisteredField() { Field = field };
            _registeredFields.Add(field, registration);

            GetRegisteredType(field.OwningType);

            return registration;
        }

 internal FieldForInstantiatedType(FieldDesc fieldDef, InstantiatedType instantiatedType)
 {
     _fieldDef = fieldDef;
     _instantiatedType = instantiatedType;
 }

        private void AddFieldReference(FieldDesc field)
        {
            if (field.IsStatic)
            {
                var owningType = (MetadataType)field.OwningType;

                Object node;
                if (field.IsThreadStatic)
                {
                    node = _nodeFactory.TypeThreadStaticsSymbol(owningType);
                }
                else
                {
                    if (field.HasGCStaticBase)
                        node = _nodeFactory.TypeGCStaticsSymbol(owningType);
                    else
                        node = _nodeFactory.TypeNonGCStaticsSymbol(owningType);
                }

                // TODO: Remove once the depedencies for static fields are tracked properly
                _writer.GetCppSignatureTypeName(owningType);

                _dependencies.Add(node);
            }
        }

 public bool GeneratesMetadata(FieldDesc fieldDef)
 {
     if (_fieldGeneratesMetadata != null)
         return _fieldGeneratesMetadata(fieldDef);
     return false;
 }

 /// <summary>
 /// Gets an object representing the static data for RVA mapped fields from the PE image.
 /// </summary>
 public ObjectNode GetFieldRvaData(FieldDesc field)
 {
     if (field.GetType() == typeof(Internal.IL.Stubs.PInvokeLazyFixupField))
     {
         var pInvokeFixup = (Internal.IL.Stubs.PInvokeLazyFixupField)field;
         PInvokeMetadata metadata = pInvokeFixup.PInvokeMetadata;
         return _nodeFactory.PInvokeMethodFixup(metadata.Module, metadata.Name);
     }
     else
     {
         return _nodeFactory.ReadOnlyDataBlob(NameMangler.GetMangledFieldName(field),
             ((EcmaField)field).GetFieldRvaData(), _typeSystemContext.Target.PointerSize);
     }
 }

 public FieldAndOffset(FieldDesc field, int offset)
 {
     Field = field;
     Offset = offset;
 }

 public string GetCppStaticFieldName(FieldDesc field)
 {
     TypeDesc type = field.OwningType;
     string typeName = GetCppTypeName(type);
     return typeName.Replace("::", "__") + "__" + _compilation.NameMangler.GetMangledFieldName(field);
 }

        private string ComputeMangledFieldName(FieldDesc field)
        {
            string prependTypeName = null;
            if (!_compilation.IsCppCodeGen)
                prependTypeName = GetMangledTypeName(field.OwningType);

            if (field is EcmaField)
            {
                var deduplicator = new HashSet<string>();

                // Add consistent names for all fields of the type, independent on the order in which
                // they are compiled
                lock (this)
                {
                    foreach (var f in field.OwningType.GetFields())
                    {
                        string name = SanitizeName(f.Name);

                        if (deduplicator.Contains(name))
                        {
                            string nameWithIndex;
                            for (int index = 1; ; index++)
                            {
                                nameWithIndex = name + "_" + index.ToString(CultureInfo.InvariantCulture);
                                if (!deduplicator.Contains(nameWithIndex))
                                    break;
                            }
                            name = nameWithIndex;
                        }
                        deduplicator.Add(name);

                        if (prependTypeName != null)
                            name = prependTypeName + "__" + name;

                        _mangledFieldNames = _mangledFieldNames.Add(f, name);
                    }
                }

                return _mangledFieldNames[field];
            }


            string mangledName = SanitizeName(field.Name);

            if (prependTypeName != null)
                mangledName = prependTypeName + "__" + mangledName;

            lock (this)
            {
                _mangledFieldNames = _mangledFieldNames.Add(field, mangledName);
            }

            return mangledName;
        }

 private CORINFO_FIELD_STRUCT_* ObjectToHandle(FieldDesc field) { return (CORINFO_FIELD_STRUCT_*)ObjectToHandle((Object)field); }