Add support for symbol table referencing large section indexes

Author: filipnavara

src/LibObjectFile.Tests/Elf/ElfSimpleTests.cs

@@ -426,16 +426,33 @@ public void TestAlignedSection()
         public void TestManySections()
         {
             var elf = new ElfObjectFile(ElfArch.X86_64);
+            var stringTable = new ElfStringTable();
+            var symbolTable = new ElfSymbolTable { Link = stringTable };
 
             for (int i = 0; i < ushort.MaxValue; i++)
             {
-                elf.AddSection(new ElfBinarySection { Name = $".section{i}" });
+                var section = new ElfBinarySection { Name = $".section{i}" };
+                elf.AddSection(section);
+                symbolTable.Entries.Add(new ElfSymbol { Type = ElfSymbolType.Section, Section = section });
             }
+
+            elf.AddSection(stringTable);
+            elf.AddSection(symbolTable);
             elf.AddSection(new ElfSectionHeaderStringTable());
 
             var diagnostics = elf.Verify();
+            Assert.True(diagnostics.HasErrors);
+            Assert.AreEqual(DiagnosticId.ELF_ERR_MissingSectionHeaderIndices, diagnostics.Messages[0].Id);
+
+            elf.AddSection(new ElfSymbolTableSectionHeaderIndices { Link = symbolTable });
+            diagnostics = elf.Verify();
             Assert.False(diagnostics.HasErrors);
 
+            for (int i = 0; i < ushort.MaxValue; i++)
+            {
+
+            }
+
             uint visibleSectionCount = elf.VisibleSectionCount;
 
             using (var outStream = File.OpenWrite("manysections"))

src/LibObjectFile/DiagnosticId.cs

@@ -69,6 +69,8 @@ public enum DiagnosticId
         ELF_ERR_InvalidStreamForSectionNoBits = 156,
         ELF_ERR_InvalidNullSection = 157,
         ELF_ERR_InvalidAlignmentOutOfRange = 158,
+        ELF_ERR_MissingSectionHeaderIndices = 159,
+        ELF_ERR_MissingNullSection = 159,
 
         AR_ERR_InvalidMagicLength = 1000,
         AR_ERR_MagicNotFound = 1001,

src/LibObjectFile/Elf/ElfObjectFile.cs

@@ -179,6 +179,12 @@ public override void Verify(DiagnosticBag diagnostics)
                 diagnostics.Error(DiagnosticId.ELF_ERR_InvalidHeaderFileClassNone, $"Cannot compute the layout with an {nameof(ElfObjectFile)} having a {nameof(FileClass)} == {ElfFileClass.None}");
             }
 
+            if (VisibleSectionCount >= ElfNative.SHN_LORESERVE &&
+                Sections[0] is not ElfNullSection)
+            {
+                diagnostics.Error(DiagnosticId.ELF_ERR_MissingNullSection, $"Section count is higher than SHN_LORESERVE ({ElfNative.SHN_LORESERVE}) but the first section is not a NULL section");                
+            }
+
             foreach (var segment in Segments)
             {
                 segment.Verify(diagnostics);

src/LibObjectFile/Elf/ElfReader{TDecoder}.cs

@@ -385,7 +385,7 @@ public override ElfSectionLink ResolveLink(ElfSectionLink link, string errorMess
             if (errorMessageFormat == null) throw new ArgumentNullException(nameof(errorMessageFormat));
 
             // Connect section Link instance
-            if (!link.IsSpecial)
+            if (!link.IsEmpty)
             {
                 if (link.SpecialIndex == _sectionStringTableIndex)
                 {
@@ -396,13 +396,21 @@ public override ElfSectionLink ResolveLink(ElfSectionLink link, string errorMess
                     var sectionIndex = link.SpecialIndex;
 
                     bool sectionFound = false;
-                    foreach (var section in ObjectFile.Sections)
+                    if (sectionIndex < ObjectFile.Sections.Count && ObjectFile.Sections[(int)sectionIndex].SectionIndex == sectionIndex)
                     {
-                        if (section.SectionIndex == sectionIndex)
+                        link = new ElfSectionLink(ObjectFile.Sections[(int)sectionIndex]);
+                        sectionFound = true;
+                    }
+                    else
+                    {
+                        foreach (var section in ObjectFile.Sections)
                         {
-                            link = new ElfSectionLink(section);
-                            sectionFound = true;
-                            break;
+                            if (section.SectionIndex == sectionIndex)
+                            {
+                                link = new ElfSectionLink(section);
+                                sectionFound = true;
+                                break;
+                            }
                         }
                     }
 
@@ -723,6 +731,9 @@ private ElfSection CreateElfSection(uint sectionIndex, ElfSectionType sectionTyp
                 case ElfSectionType.Note:
                     section = new ElfNoteTable();
                     break;
+                case ElfSectionType.SymbolTableSectionHeaderIndices:
+                    section = new ElfSymbolTableSectionHeaderIndices();
+                    break;
             }
 
             // If the section is not a builtin section, try to offload to a delegate

src/LibObjectFile/Elf/Sections/ElfSymbolTable.cs

@@ -149,7 +149,8 @@ private void Write32(ElfWriter writer)
                 writer.Encode(out sym.st_size, (uint)entry.Size);
                 sym.st_info = (byte)(((byte) entry.Bind << 4) | (byte) entry.Type);
                 sym.st_other = (byte) ((byte) entry.Visibility & 3);
-                writer.Encode(out sym.st_shndx, (ElfNative.Elf32_Half) entry.Section.GetIndex());
+                var sectionIndex = entry.Section.GetIndex();
+                writer.Encode(out sym.st_shndx, sectionIndex < ElfNative.SHN_LORESERVE || entry.Section.IsSpecial ? (ElfNative.Elf32_Half)sectionIndex : (ElfNative.Elf32_Half)ElfNative.SHN_XINDEX);
 
                 writer.Write(sym);
             }
@@ -169,7 +170,8 @@ private void Write64(ElfWriter writer)
                 writer.Encode(out sym.st_size, entry.Size);
                 sym.st_info = (byte)(((byte)entry.Bind << 4) | (byte)entry.Type);
                 sym.st_other = (byte)((byte)entry.Visibility & 3);
-                writer.Encode(out sym.st_shndx, (ElfNative.Elf64_Half)entry.Section.GetIndex());
+                var sectionIndex = entry.Section.GetIndex();
+                writer.Encode(out sym.st_shndx, sectionIndex < ElfNative.SHN_LORESERVE || entry.Section.IsSpecial ? (ElfNative.Elf64_Half)sectionIndex : (ElfNative.Elf64_Half)ElfNative.SHN_XINDEX);
 
                 writer.Write(sym);
             }
@@ -183,6 +185,7 @@ protected override void AfterRead(ElfReader reader)
             for (int i = 0; i < Entries.Count; i++)
             {
                 var entry = Entries[i];
+
                 if (stringTable != null)
                 {
                     if (stringTable.TryResolve(entry.Name, out var newEntry))
@@ -195,7 +198,10 @@ protected override void AfterRead(ElfReader reader)
                     }
                 }
 
-                entry.Section = reader.ResolveLink(entry.Section, $"Invalid link section index {entry.Section.SpecialIndex} for  symbol table entry [{i}] from symbol table section [{this}]");
+                if (entry.Section.SpecialIndex < ElfNative.SHN_LORESERVE)
+                {
+                    entry.Section = reader.ResolveLink(entry.Section, $"Invalid link section index {entry.Section.SpecialIndex} for  symbol table entry [{i}] from symbol table section [{this}]");
+                }
 
                 Entries[i] = entry;
             }
@@ -212,6 +218,7 @@ public override void Verify(DiagnosticBag diagnostics)
             }
 
             bool isAllowingLocal = true;
+            bool needsSectionHeaderIndices = false;
 
             for (int i = 0; i < Entries.Count; i++)
             {
@@ -222,9 +229,14 @@ public override void Verify(DiagnosticBag diagnostics)
                     diagnostics.Error(DiagnosticId.ELF_ERR_InvalidFirstSymbolEntryNonNull, $"Invalid entry #{i} in the {nameof(ElfSymbolTable)} section [{Index}]. The first entry must be null/undefined");
                 }
 
-                if (entry.Section.Section != null && entry.Section.Section.Parent != Parent)
+                if (entry.Section.Section != null)
                 {
-                    diagnostics.Error(DiagnosticId.ELF_ERR_InvalidSymbolEntrySectionParent, $"Invalid section for the symbol entry #{i} in the {nameof(ElfSymbolTable)} section [{Index}]. The section of the entry `{entry}` must the same than this symbol table section");
+                    if (entry.Section.Section.Parent != Parent)
+                    {
+                        diagnostics.Error(DiagnosticId.ELF_ERR_InvalidSymbolEntrySectionParent, $"Invalid section for the symbol entry #{i} in the {nameof(ElfSymbolTable)} section [{Index}]. The section of the entry `{entry}` must the same than this symbol table section");
+                    }
+
+                    needsSectionHeaderIndices |= entry.Section.GetIndex() >= ElfNative.SHN_LORESERVE;
                 }
 
                 stringTable.ReserveString(entry.Name);
@@ -244,6 +256,24 @@ public override void Verify(DiagnosticBag diagnostics)
                     isAllowingLocal = false;
                 }
             }
+
+            if (needsSectionHeaderIndices)
+            {
+                bool foundSectionHeaderIndices = false;
+                foreach (ElfSection otherSection in Parent.Sections)
+                {
+                    if (otherSection is ElfSymbolTableSectionHeaderIndices && otherSection.Link.Section == this)
+                    {
+                        foundSectionHeaderIndices = true;
+                        break;
+                    }
+                }
+
+                if (!foundSectionHeaderIndices)
+                {
+                    diagnostics.Error(DiagnosticId.ELF_ERR_MissingSectionHeaderIndices, $"Symbol table [{Name.Value}] references section indexes higher than SHN_LORESERVE and accompanying {nameof(ElfSymbolTableSectionHeaderIndices)} section is missing");
+                }
+            }
         }
 
         public override unsafe void UpdateLayout(DiagnosticBag diagnostics)

src/LibObjectFile/Elf/Sections/ElfSymbolTableSectionHeaderIndices.cs

@@ -0,0 +1,112 @@
+// Copyright (c) Alexandre Mutel. All rights reserved.
+// This file is licensed under the BSD-Clause 2 license.
+// See the license.txt file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+
+namespace LibObjectFile.Elf
+{
+    /// <summary>
+    /// A section with the type <see cref="ElfSectionType.SymbolTableSectionHeaderIndices"/>
+    /// </summary>
+    public sealed class ElfSymbolTableSectionHeaderIndices : ElfSection
+    {
+        public const string DefaultName = ".symtab_shndx";
+
+        private readonly List<ElfSectionLink> _entries;
+
+        public ElfSymbolTableSectionHeaderIndices() : base(ElfSectionType.SymbolTableSectionHeaderIndices)
+        {
+            Name = DefaultName;
+            _entries = new List<ElfSectionLink>();
+        }
+
+        public override ElfSectionType Type
+        {
+            get => base.Type;
+            set
+            {
+                if (value != ElfSectionType.SymbolTableSectionHeaderIndices)
+                {
+                    throw new ArgumentException($"Invalid type `{Type}` of the section [{Index}] `{nameof(ElfSymbolTableSectionHeaderIndices)}`. Only `{ElfSectionType.SymbolTableSectionHeaderIndices}` is valid");
+                }
+                base.Type = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets a list of <see cref="ElfSectionLink"/> entries.
+        /// </summary>
+        public IReadOnlyList<ElfSectionLink> Entries => _entries;
+
+        public override unsafe ulong TableEntrySize => sizeof(uint);
+
+        protected override void Read(ElfReader reader)
+        {
+            var numberOfEntries = base.Size / TableEntrySize;
+            _entries.Clear();
+            _entries.Capacity = (int)numberOfEntries;
+            for (ulong i = 0; i < numberOfEntries; i++)
+            {
+                _entries.Add(new ElfSectionLink(reader.ReadU32()));
+            }
+        }
+
+        protected override void Write(ElfWriter writer)
+        {
+            // Write all entries
+            for (int i = 0; i < Entries.Count; i++)
+            {
+                writer.WriteU32(Entries[i].GetIndex());
+            }
+        }
+
+        protected override void AfterRead(ElfReader reader)
+        {
+            // Verify that the link is safe and configured as expected
+            Link.TryGetSectionSafe<ElfSymbolTable>(nameof(ElfSymbolTableSectionHeaderIndices), nameof(Link), this, reader.Diagnostics, out var symbolTable, ElfSectionType.SymbolTable, ElfSectionType.DynamicLinkerSymbolTable);
+
+            for (int i = 0; i < _entries.Count; i++)
+            {
+                var entry = _entries[i];
+                if (entry.SpecialIndex != 0)
+                {
+                    entry = reader.ResolveLink(entry.Section, $"Invalid link section index {entry.SpecialIndex} for symbol table entry [{i}] from symbol table section [{this}]");
+                    _entries[i] = entry;
+
+                    // Update the link in symbol table
+                    var symbolTableEntry = symbolTable.Entries[i];
+                    symbolTableEntry.Section = entry.Section;
+                    symbolTable.Entries[i] = symbolTableEntry;
+                }
+            }
+        }
+
+        public override void Verify(DiagnosticBag diagnostics)
+        {
+            base.Verify(diagnostics);
+
+            // Verify that the link is safe and configured as expected
+            if (!Link.TryGetSectionSafe<ElfSymbolTable>(nameof(ElfSymbolTableSectionHeaderIndices), nameof(Link), this, diagnostics, out var symbolTable, ElfSectionType.SymbolTable, ElfSectionType.DynamicLinkerSymbolTable))
+            {
+                return;
+            }
+
+            for (int i = 0; i < _entries.Count; i++)
+            {
+                var entry = _entries[i];
+                if (entry.SpecialIndex != 0 && entry.Section != null && entry.Section.Parent != Parent)
+                {
+                    diagnostics.Error(DiagnosticId.ELF_ERR_InvalidSymbolEntrySectionParent, $"Invalid section for the symbol entry #{i} in the {nameof(ElfSymbolTable)} section [{Index}]");
+                }
+            }
+        }
+
+        public override unsafe void UpdateLayout(DiagnosticBag diagnostics)
+        {
+            if (diagnostics == null) throw new ArgumentNullException(nameof(diagnostics));
+            Size = Parent == null || Parent.FileClass == ElfFileClass.None ? 0 : (ulong)Entries.Count * sizeof(uint);
+        }
+    }
+}