/// <summary>
 /// Initializes a new instance of the <see cref="Elf32Section"/> class.
 /// </summary>
 /// <param name="kind">The kind of the section.</param>
 /// <param name="name">The name.</param>
 /// <param name="virtualAddress">The virtualAddress.</param>
 public Elf32Section(SectionKind kind, string name, IntPtr virtualAddress)
     : base(kind, name, virtualAddress)
 {
     _header = new Elf32SectionHeader();
     _header.Name = Elf32StringTableSection.AddString(name);
     _sectionStream = new System.IO.MemoryStream();
 }

 internal LinkerSymbol(string name, SectionKind kind, uint alignment)
 {
     Name = name;
     Alignment = alignment;
     SectionKind = kind;
     LinkRequests = new List<LinkRequest>();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Section"/> class.
 /// </summary>
 /// <param name="kind">The kind of the section.</param>
 /// <param name="name">The name.</param>
 /// <param name="virtualAddress">The virtualAddress.</param>
 public Section(SectionKind kind, string name, IntPtr virtualAddress)
     : base(kind, name, virtualAddress)
 {
     header = new SectionHeader();
     header.Name = StringTableSection.AddString(name);
     stream = new MemoryStream();
 }

 public LinkerSection(SectionKind sectionKind, uint alignment)
 {
     SectionKind = sectionKind;
     IsResolved = false;
     symbolLookup = new Dictionary<string, LinkerSymbol>();
     Symbols = new List<LinkerSymbol>();
     SectionAlignment = alignment;
     Size = 0;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="SimLinkerSection" /> class.
        /// </summary>
        /// <param name="kind">The kind of the section.</param>
        /// <param name="name">The name.</param>
        /// <param name="address">The address.</param>
        /// <param name="size">The size.</param>
        /// <param name="simAdapter">The sim adapter.</param>
        public SimLinkerSection(SectionKind kind, string name, uint address, uint size, ISimAdapter simAdapter)
            : base(kind, name, 0)
        {
            Memory = new byte[size];

            VirtualAddress = address;

            simAdapter.SimCPU.AddMemory(address, size, 1);

            stream = new MemoryStream(Memory, true);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LinkerSymbol"/> class.
        /// </summary>
        /// <param name="name">The name of the symbol.</param>
        /// <param name="section">The section holding the symbol.</param>
        /// <param name="sectionAddress">Holds the section relative address of the symbol.</param>
        /// <exception cref="T:System.ArgumentException"><paramref name="name"/> is empty.</exception>
        /// <exception cref="T:System.ArgumentNullException"><paramref name="name"/> is null.</exception>
        public LinkerSymbol(string name, SectionKind section, long sectionAddress)
        {
            Debug.Assert(!String.IsNullOrEmpty(name), @"LinkerSymbol requires a proper name.");
            if (name == null)
                throw new ArgumentNullException(@"name");
            if (name.Length == 0)
                throw new ArgumentException(@"Name can't be empty.", @"name");

            this.name = name;
            this.section = section;
            this.sectionAddress = sectionAddress;
        }

 private void AllocateSpace(RuntimeField field, SectionKind section, int size, int alignment)
 {
     using (Stream stream = linker.Allocate(field.ToString(), section, size, alignment))
     {
         if (field.RVA != 0)
         {
             InitializeStaticValueFromRVA(stream, size, field);
         }
         else
         {
             stream.WriteZeroBytes(size);
         }
     }
 }

 private void AllocateSpace(MosaField field, SectionKind section, int size, int alignment)
 {
     using (var stream = Compiler.Linker.Allocate(field.FullName, section, size, alignment))
     {
         if (field.Data != null)
         {
             stream.Write(field.Data, 0, size);
         }
         else
         {
             stream.WriteZeroBytes(size);
         }
     }
 }

 /// <summary>
 /// Allocates a symbol of the given name in the specified section.
 /// </summary>
 /// <param name="name">The name of the symbol.</param>
 /// <param name="section">The executable section to allocate From.</param>
 /// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
 /// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
 /// <returns>
 /// A stream, which can be used to populate the section.
 /// </returns>
 public virtual Stream Allocate(string name, SectionKind section, int size, int alignment)
 {
     return null;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Section"/> class.
 /// </summary>
 /// <param name="kind">The kind of the section.</param>
 /// <param name="name">The name of the section.</param>
 /// <param name="virtualAddress">The virtualAddress of the section.</param>
 public Section(SectionKind kind, string name, IntPtr virtualAddress)
     : base(kind, name, virtualAddress)
 {
     stream = new MemoryStream();
 }

        private uint GetSectionLength(SectionKind sectionKind)
        {
            LinkerSection section;
            if (this.sections.TryGetValue(sectionKind, out section) == true && section.Length > 0)
                return (uint)section.Length;

            return 0;
        }

 protected LinkerSection GetSection(SectionKind kind)
 {
     return Sections[(int)kind];
 }

        public void Link(LinkType linkType, PatchType patchType, LinkerSymbol patchSymbol, int patchOffset, int relativeBase, string referenceSymbol, SectionKind patchRelativeBase, int referenceOffset)
        {
            var referenceObject = GetSymbol(referenceSymbol, patchRelativeBase);

            Link(linkType, patchType, patchSymbol, patchOffset, relativeBase, referenceObject, referenceOffset);
        }

 public LinkerSymbol GetSymbol(string name, SectionKind kind)
 {
     return CreateSymbol(name, kind, 0);
 }

 /// <summary>
 /// Allocates a symbol of the given name in the specified section.
 /// </summary>
 /// <param name="section">The executable section to allocate From.</param>
 /// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
 /// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
 /// <returns>
 /// A stream, which can be used to populate the section.
 /// </returns>
 protected abstract Stream Allocate(SectionKind section, int size, int alignment);

 /// <summary>
 /// Gets the section.
 /// </summary>
 /// <param name="sectionKind">Kind of the section.</param>
 /// <returns>The section of the requested kind.</returns>
 public abstract LinkerSection GetSection(SectionKind sectionKind);

 /// <summary>
 /// Allocates a symbol of the given name in the specified section.
 /// </summary>
 /// <param name="section">The executable section to allocate From.</param>
 /// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
 /// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
 /// <returns>
 /// A stream, which can be used to populate the section.
 /// </returns>
 protected override Stream Allocate(SectionKind section, int size, int alignment)
 {
     Section linkerSection = (Section)GetSection(section);
     return linkerSection.Allocate(size, alignment);
 }

 /// <summary>
 /// Retrieves a linker section by its type.
 /// </summary>
 /// <param name="sectionKind">The type of the section to retrieve.</param>
 /// <returns>The retrieved linker section.</returns>
 public override LinkerSection GetSection(SectionKind sectionKind)
 {
     return this.sections[(int)sectionKind];
 }

 /// <summary>
 /// Allocates memory in the specified section.
 /// </summary>
 /// <param name="symbol">The metadata member to allocate space for.</param>
 /// <param name="section">The executable section to allocate From.</param>
 /// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
 /// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
 /// <returns>A stream, which can be used to populate the section.</returns>
 public Stream Allocate(RuntimeMember symbol, SectionKind section, int size, int alignment)
 {
     CheckImplementation();
     return this.implementation.Allocate(symbol, section, size, alignment);
 }

 /// <summary>
 /// Allocates a symbol of the given name in the specified section.
 /// </summary>
 /// <param name="section">The executable section to allocate From.</param>
 /// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
 /// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
 /// <returns>
 /// A stream, which can be used to populate the section.
 /// </returns>
 protected override System.IO.Stream Allocate(SectionKind section, int size, int alignment)
 {
     Elf64.Sections.Elf64Section linkerSection = (Elf64.Sections.Elf64Section)GetSection(section);
     return linkerSection.Allocate(size, alignment);
 }