**** Merged from MCS ****

[mono-project.git] / mcs / class / Mono.PEToolkit / CorHeader.cs

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
/*
 * Copyright (c) 2002 Sergey Chaban <serge@wildwestsoftware.com>
 */

using System;
using System.IO;
using System.Runtime.InteropServices;

using Mono.PEToolkit.Metadata;

namespace Mono.PEToolkit {

        [Flags]
        public enum CorFlags : uint {
                /// <summary>
                /// COMIMAGE_FLAGS_ILONLY
                /// </summary>
                ILONLY = 0x00000001,
                
                /// <summary>
                /// COMIMAGE_FLAGS_32BITREQUIRED
                /// </summary>
                REQUIRED_32BIT = 0x00000002,
                
                /// <summary>
                /// COMIMAGE_FLAGS_IL_LIBRARY
                /// </summary>
                IL_LIBRARY = 0x00000004,
                
                /// <summary>
                /// COMIMAGE_FLAGS_TRACKDEBUGDATA
                /// </summary>
                TRACKDEBUGDATA = 0x00010000,
        }


        /// <summary>
        /// CLR 2.0 header structure.
        /// IMAGE_COR20_HEADER
        /// </summary>
        public class CorHeader {
                // Header versioning
                internal uint cb;
                internal short runtimeMaj;
                internal short runtimeMin;

                // Symbol table and startup information.
                internal DataDir meta;
                internal CorFlags flags;
                internal uint entryTok;

                // Binding information.
                internal DataDir rsrc;
                internal DataDir strongSig;

                // Regular fixup and binding information.
                internal DataDir codeManTab;
                internal DataDir vtab;
                internal DataDir jumps;

                // Managed Native Code.
                internal DataDir eeInfo;
                internal DataDir helper;
                internal DataDir dynInfo;
                internal DataDir delayInfo;
                internal DataDir modImg;
                internal DataDir extFixups;
                internal DataDir ridMap;
                internal DataDir dbgMap;

                // obsolete?
                internal DataDir ipMap;


                //
                // Accessors
                //

                public uint Size {
                        get {
                                return cb;
                        }
                        set {
                                cb = value;
                        }
                }

                public short MajorRuntimeVersion {
                        get {
                                return runtimeMaj;
                        }
                        set {
                                runtimeMaj = value;
                        }
                }

                public short MinorRuntimeVersion {
                        get {
                                return runtimeMin;
                        }
                        set {
                                runtimeMin = value;
                        }
                }

                public string RuntimeVersion {
                        get {
                                return String.Format("{0}.{1}", runtimeMaj, runtimeMin);
                        }
                }

                public DataDir MetaData {
                        get {
                                return meta;
                        }
                        set {
                                meta = value;
                        }
                }
                
                public CorFlags Flags {
                        get {
                                return flags;
                        }
                        set {
                                flags = value;
                        }
                }
                
                public MDToken EntryPointToken {
                        get {
                                return entryTok;
                        }
                        set {
                                entryTok = value;
                        }
                }

                public DataDir Resources {
                        get {
                                return rsrc;
                        }
                        set {
                                rsrc = value;
                        }
                }
                
                public DataDir StrongNameSignature {
                        get {
                                return strongSig;
                        }
                        set {
                                strongSig = value;
                        }
                }

                public DataDir CodeManagerTable {
                        get {
                                return codeManTab;
                        }
                        set {
                                codeManTab = value;
                        }
                }
                
                public DataDir VTableFixups {
                        get {
                                return vtab;
                        }
                        set {
                                vtab = value;
                        }
                }
                
                public DataDir ExportAddressTableJumps {
                        get {
                                return jumps;
                        }
                        set {
                                jumps = value;
                        }
                }


                public DataDir EEInfoTable {
                        get {
                                return eeInfo;
                        }
                        set {
                                eeInfo = value;
                        }
                }

                public DataDir HelperTable {
                        get {
                                return helper;
                        }
                        set {
                                helper = value;
                        }
                }
                
                public DataDir DynamicInfo {
                        get {
                                return dynInfo;
                        }
                        set {
                                dynInfo = value;
                        }
                }
                
                public DataDir DelayLoadInfo {
                        get {
                                return delayInfo;
                        }
                        set {
                                delayInfo = value;
                        }
                }
                
                public DataDir ModuleImage {
                        get {
                                return modImg;
                        }
                        set {
                                modImg = value;
                        }
                }
                
                public DataDir ExternalFixups {
                        get {
                                return extFixups;
                        }
                        set {
                                extFixups = value;
                        }
                }
                
                public DataDir RidMap {
                        get {
                                return ridMap;
                        }
                        set {
                                ridMap = value;
                        }
                }
                
                public DataDir DebugMap {
                        get {
                                return dbgMap;
                        }
                        set {
                                dbgMap = value;
                        }
                }


                public DataDir IPMap {
                        get {
                                return ipMap;
                        }
                        set {
                                ipMap = value;
                        }
                }


                public void Read(BinaryReader reader)
                {
                        // Header versioning
                        cb = reader.ReadUInt32 ();
                        
                        runtimeMaj = reader.ReadInt16 ();
                        runtimeMin = reader.ReadInt16 ();
        
                        
                        // Symbol table and startup information.
                        meta = new DataDir (reader);
                        flags = (CorFlags) reader.ReadUInt32 ();
                        entryTok = reader.ReadUInt32 ();

                        // Binding information.
                        rsrc  = new DataDir (reader);
                        strongSig = new DataDir (reader);
                
                        // Regular fixup and binding information.
                        codeManTab = new DataDir (reader);
                        vtab = new DataDir (reader);
                        jumps = new DataDir (reader);

                        // Managed Native Code.
                        eeInfo = new DataDir (reader);
                        helper = new DataDir (reader);
                        dynInfo = new DataDir (reader);
                        delayInfo = new DataDir (reader);
                        modImg = new DataDir (reader);
                        extFixups = new DataDir (reader);
                        ridMap = new DataDir (reader);
                        dbgMap = new DataDir (reader);

                        // obsolete?
                        ipMap = new DataDir (reader);
                }

                public void Write (BinaryWriter writer)
                {
                        // Header versioning
                        writer.Write (cb);
                        
                        writer.Write (runtimeMaj);
                        writer.Write (runtimeMin);
                                
                        // Symbol table and startup information.
                        meta.Write (writer);
                        writer.Write ((uint)flags);
                        writer.Write (entryTok);

                        // Binding information.
                        rsrc.Write (writer);
                        strongSig.Write (writer);
                
                        // Regular fixup and binding information.
                        codeManTab.Write (writer);
                        vtab.Write (writer);
                        jumps.Write (writer);

                        // Managed Native Code.
                        eeInfo.Write (writer);
                        helper.Write (writer);
                        dynInfo.Write (writer);
                        delayInfo.Write (writer);
                        modImg.Write (writer);
                        extFixups.Write (writer);
                        ridMap.Write (writer);
                        dbgMap.Write (writer);

                        // obsolete?
                        ipMap.Write (writer);
                }


                public void Dump(TextWriter writer)
                {
                        writer.WriteLine(String.Format (
                                "Header Size                : {0}"  + Environment.NewLine +
                                "Runtime Version            : {1}"  + Environment.NewLine +
                                "MetaData Root              : {2}"  + Environment.NewLine +
                                "Flags                      : {3}"  + Environment.NewLine +
                                "Entry Point Token          : {4}"  + Environment.NewLine +
                                "Resources                  : {5}"  + Environment.NewLine +
                                "Strong Name Signature      : {6}"  + Environment.NewLine +
                                "Code Manager Table         : {7}"  + Environment.NewLine +
                                "VTable Fixups              : {8}"  + Environment.NewLine +
                                "Export Address Table Jumps : {9}"  + Environment.NewLine +
                                "EE Info Table              : {10}"  + Environment.NewLine +
                                "Helper Table               : {11}"  + Environment.NewLine +
                                "Dynamic Info               : {12}"  + Environment.NewLine +
                                "Delay Load Info            : {13}"  + Environment.NewLine +
                                "Module Image               : {14}"  + Environment.NewLine +
                                "External Fixups            : {15}"  + Environment.NewLine +
                                "Rid Map                    : {16}"  + Environment.NewLine +
                                "Debug Map                  : {17}"  + Environment.NewLine +
                                "IP Map                     : {18}"  + Environment.NewLine +
                                "Runtime Major              : {19}"  + Environment.NewLine +
                                "Runtime Minor              : {20}" + Environment.NewLine,
                                cb,
                                RuntimeVersion,
                                meta, null, EntryPointToken,
                                rsrc, strongSig,
                                codeManTab, vtab, jumps,
                                eeInfo, helper, dynInfo, delayInfo, modImg, extFixups,
                                ridMap, dbgMap, ipMap, MajorRuntimeVersion, MinorRuntimeVersion
                        ));
                        
                }

                /// <summary>
                /// </summary>
                /// <returns></returns>
                public override string ToString() {
                        StringWriter sw = new StringWriter();
                        Dump(sw);
                        return sw.ToString();
                }


        }
}