[GR-34177] Don't differentiate between explicit and implicit relocation addend.

PullRequest: graal/9980

Author: teshull

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/BasicProgbitsSectionImpl.java

@@ -113,21 +113,21 @@ public List<Section> getElements() {
     }
 
     @Override
-    public void markRelocationSite(int offset, RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend) {
-        ((RelocatableSectionImpl) getElement()).markRelocationSite(offset, ByteBuffer.wrap(getContent()).order(getOwner().getByteOrder()), k, symbolName, useImplicitAddend,
-                        explicitAddend);
+    public void markRelocationSite(int offset, RelocationKind k, String symbolName, long addend) {
+        ((RelocatableSectionImpl) getElement()).markRelocationSite(offset, ByteBuffer.wrap(getContent()).order(getOwner().getByteOrder()), k, symbolName,
+                        addend);
     }
 
     @Override
-    public final void markRelocationSite(int offset, ByteBuffer bb, RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend) {
+    public final void markRelocationSite(int offset, ByteBuffer bb, RelocationKind k, String symbolName, long addend) {
         assert getContent() == null || bb.array() == getContent();
-        ((RelocatableSectionImpl) getElement()).markRelocationSite(offset, bb, k, symbolName, useImplicitAddend, explicitAddend);
+        ((RelocatableSectionImpl) getElement()).markRelocationSite(offset, bb, k, symbolName, addend);
     }
 
     @Override
-    public Element getOrCreateRelocationElement(boolean useImplicitAddend) {
+    public Element getOrCreateRelocationElement(long addend) {
         // FIXME: This looks suspicious: turning an Element back into an Impl?
-        return ((RelocatableSectionImpl) getElement()).getOrCreateRelocationElement(useImplicitAddend);
+        return ((RelocatableSectionImpl) getElement()).getOrCreateRelocationElement(addend);
     }
 
     @Override

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/ObjectFile.java

@@ -358,11 +358,6 @@ public static int getRelocationSize(RelocationKind kind) {
      * Interface implemented by objects implementing a specific relocation method and size.
      */
     public interface RelocationMethod {
-
-        boolean canUseImplicitAddend();
-
-        boolean canUseExplicitAddend();
-
         /*
          * If we were implementing a linker, we'd have a method something like
          *
@@ -412,24 +407,22 @@ public interface RelocatableSectionImpl extends ElementImpl {
          * @param k the kind of fixup to be applied
          * @param symbolName the name of the symbol whose value is used to compute the fixed-up
          *            bytes
-         * @param useImplicitAddend whether the current bytes are to be used as an addend
-         * @param explicitAddend a full-width addend, or null if useImplicitAddend is true
+         * @param addend a full-width addend, or 0 if unneeded
          */
-        void markRelocationSite(int offset, ByteBuffer bb, RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend);
+        void markRelocationSite(int offset, ByteBuffer bb, RelocationKind k, String symbolName, long addend);
 
         /**
          * Force the creation of a relocation section/element for this section, and return it. This
          * is necessary to avoid the on-demand instantiation of relocation sections at write()-time,
          * which leads to unpredictable results (e.g. not appearing in the ELF SHT, if the SHT was
          * written before the section was created).
          *
-         * @param useImplicitAddend whether the relocation section of interest is for implicit
-         *            addends
+         * @param addend whether a full-width addend, or 0 if unneeded
          *
          * @return the element which will hold relocation records (of the argument-specified kind)
          *         for this section
          */
-        Element getOrCreateRelocationElement(boolean useImplicitAddend);
+        Element getOrCreateRelocationElement(long addend);
     }
 
     /**
@@ -446,7 +439,7 @@ public interface ProgbitsSectionImpl extends RelocatableSectionImpl {
          * passed a buffer. It uses the byte array accessed by {@link #getContent} and
          * {@link #setContent}.
          */
-        void markRelocationSite(int offset, RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend);
+        void markRelocationSite(int offset, RelocationKind k, String symbolName, long addend);
     }
 
     public interface NobitsSectionImpl extends ElementImpl {

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/StringSectionImpl.java

@@ -119,17 +119,17 @@ public StringSectionImpl() {
      */
 
     @Override
-    public Element getOrCreateRelocationElement(boolean useImplicitAddend) {
+    public Element getOrCreateRelocationElement(long addend) {
         throw new UnsupportedOperationException("can't mark relocaction sites in string section");
     }
 
     @Override
-    public void markRelocationSite(int offset, RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend) {
+    public void markRelocationSite(int offset, RelocationKind k, String symbolName, long addend) {
         throw new UnsupportedOperationException("can't mark relocaction sites in string section");
     }
 
     @Override
-    public void markRelocationSite(int offset, ByteBuffer bb, RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend) {
+    public void markRelocationSite(int offset, ByteBuffer bb, RelocationKind k, String symbolName, long addend) {
         throw new UnsupportedOperationException("can't mark relocaction sites in string section");
     }
 

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/elf/ELFMachine.java

@@ -33,12 +33,6 @@
  * ELF machine type (incomplete). Each machine type also defines its set of relocation types.
  */
 public enum ELFMachine/* implements Integral */ {
-    NONE {
-        @Override
-        Class<? extends Enum<? extends RelocationMethod>> relocationTypes() {
-            return ELFDummyRelocation.class;
-        }
-    },
     X86_64 {
         @Override
         Class<? extends Enum<? extends RelocationMethod>> relocationTypes() {
@@ -136,16 +130,13 @@ public static ELFRelocationMethod getRelocation(ELFMachine m, RelocationKind k)
 
                 }
             default:
-            case NONE:
-                return ELFDummyRelocation.R_NONE;
+                throw new IllegalStateException("unknown ELF machine type");
         }
     }
 
     // TODO: use explicit enum values
     public static ELFMachine from(int m) {
         switch (m) {
-            case 0:
-                return NONE;
             case 0x3E:
                 return X86_64;
             case 0xB7:
@@ -156,9 +147,7 @@ public static ELFMachine from(int m) {
     }
 
     public short toShort() {
-        if (this == NONE) {
-            return 0;
-        } else if (this == AArch64) {
+        if (this == AArch64) {
             return 0xB7;
         } else if (this == X86_64) {
             return 0x3E;
@@ -176,25 +165,6 @@ public static ELFMachine getSystemNativeValue() {
     }
 }
 
-enum ELFDummyRelocation implements ELFRelocationMethod {
-    R_NONE;
-
-    @Override
-    public boolean canUseExplicitAddend() {
-        return true;
-    }
-
-    @Override
-    public boolean canUseImplicitAddend() {
-        return true;
-    }
-
-    @Override
-    public long toLong() {
-        return ordinal();
-    }
-}
-
 enum ELFX86_64Relocation implements ELFRelocationMethod {
     // These are all named R_X86_64_... in elf.h,
     // but we just use R_... to keep it short.
@@ -245,19 +215,6 @@ enum ELFX86_64Relocation implements ELFRelocationMethod {
         assert R_COUNT.ordinal() == 39;
     }
 
-    /*
-     * x86-64 relocs always use explicit addends.
-     */
-    @Override
-    public boolean canUseExplicitAddend() {
-        return true;
-    }
-
-    @Override
-    public boolean canUseImplicitAddend() {
-        return false;
-    }
-
     @Override
     public long toLong() {
         return ordinal();
@@ -398,16 +355,6 @@ enum ELFAArch64Relocation implements ELFRelocationMethod {
         this.code = code;
     }
 
-    @Override
-    public boolean canUseImplicitAddend() {
-        return false;
-    }
-
-    @Override
-    public boolean canUseExplicitAddend() {
-        return true;
-    }
-
     @Override
     public long toLong() {
         return code;

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/elf/ELFObjectFile.java

@@ -35,6 +35,9 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.graalvm.nativeimage.ImageSingletons;
+import org.graalvm.nativeimage.Platform;
+
 import com.oracle.objectfile.BuildDependency;
 import com.oracle.objectfile.ElementImpl;
 import com.oracle.objectfile.LayoutDecision;
@@ -45,15 +48,13 @@
 import com.oracle.objectfile.debuginfo.DebugInfoProvider;
 import com.oracle.objectfile.elf.dwarf.DwarfARangesSectionImpl;
 import com.oracle.objectfile.elf.dwarf.DwarfAbbrevSectionImpl;
+import com.oracle.objectfile.elf.dwarf.DwarfDebugInfo;
 import com.oracle.objectfile.elf.dwarf.DwarfFrameSectionImpl;
 import com.oracle.objectfile.elf.dwarf.DwarfInfoSectionImpl;
 import com.oracle.objectfile.elf.dwarf.DwarfLineSectionImpl;
-import com.oracle.objectfile.elf.dwarf.DwarfDebugInfo;
 import com.oracle.objectfile.elf.dwarf.DwarfStrSectionImpl;
 import com.oracle.objectfile.io.AssemblyBuffer;
 import com.oracle.objectfile.io.OutputAssembler;
-import org.graalvm.nativeimage.ImageSingletons;
-import org.graalvm.nativeimage.Platform;
 
 /**
  * Represents an ELF object file (of any kind: relocatable, shared library, executable, core, ...).
@@ -469,9 +470,9 @@ public class ELFHeader extends ObjectFile.Header {
          */
         class Struct {
 
-            IdentStruct ident = new IdentStruct();
-            ELFType type;
-            ELFMachine machine;
+            final IdentStruct ident;
+            final ELFType type;
+            final ELFMachine machine;
             int version;
             long entry;
             long phoff;
@@ -484,10 +485,10 @@ class Struct {
             short shnum;
             short shstrndx;
 
-            Struct() {
+            Struct(ELFType type, ELFMachine machine) {
                 ident = new IdentStruct();
-                type = ELFType.NONE;
-                machine = ELFMachine.NONE;
+                this.type = type;
+                this.machine = machine;
             }
 
             /**
@@ -618,16 +619,15 @@ public Iterable<BuildDependency> getDependencies(Map<Element, LayoutDecisionMap>
         public byte[] getOrDecideContent(Map<Element, LayoutDecisionMap> alreadyDecided, byte[] contentHint) {
             // we serialize ourselves by writing a Struct to a bytebuffer
             OutputAssembler oa = AssemblyBuffer.createOutputAssembler(getDataEncoding().toByteOrder());
-            Struct contents = new Struct(); // also creates ident struct, which we need to populate
+            /* Also creates ident struct, which we need to populate. */
+            Struct contents = new Struct(getType(), getMachine());
 
             // don't assign magic -- its default value is correct
             contents.ident.fileClass = getFileClass();
             contents.ident.dataEncoding = getDataEncoding();
             contents.ident.version = getVersion();
             contents.ident.osabi = getOsAbi();
             contents.ident.abiVersion = (char) getAbiVersion();
-            contents.type = getType();
-            contents.machine = getMachine();
             contents.version = getVersion();
             contents.entry = 0;
             contents.shoff = (int) alreadyDecided.get(sht).getDecidedValue(LayoutDecision.Kind.OFFSET);
@@ -668,7 +668,7 @@ public int getOrDecideOffset(Map<Element, LayoutDecisionMap> alreadyDecided, int
 
         @Override
         public int getOrDecideSize(Map<Element, LayoutDecisionMap> alreadyDecided, int sizeHint) {
-            int size = (new Struct()).getWrittenSize();
+            int size = (new Struct(getType(), getMachine())).getWrittenSize();
             assert sizeHint == -1 || sizeHint == size;
             return size;
         }
@@ -1193,13 +1193,19 @@ public void installDebugInfo(DebugInfoProvider debugInfoProvider) {
          * decision set and causes an NPE during reloc section write. So we need to create the
          * relevant reloc sections here in advance.
          */
-        elfStrSectionImpl.getOrCreateRelocationElement(false);
-        elfAbbrevSectionImpl.getOrCreateRelocationElement(false);
-        frameSectionImpl.getOrCreateRelocationElement(false);
-        elfInfoSectionImpl.getOrCreateRelocationElement(false);
-        elfARangesSectionImpl.getOrCreateRelocationElement(false);
-        elfLineSectionImpl.getOrCreateRelocationElement(false);
+        elfStrSectionImpl.getOrCreateRelocationElement(0);
+        elfAbbrevSectionImpl.getOrCreateRelocationElement(0);
+        frameSectionImpl.getOrCreateRelocationElement(0);
+        elfInfoSectionImpl.getOrCreateRelocationElement(0);
+        elfARangesSectionImpl.getOrCreateRelocationElement(0);
+        elfLineSectionImpl.getOrCreateRelocationElement(0);
         /* Ok now we can populate the debug info model. */
         dwarfSections.installDebugInfo(debugInfoProvider);
     }
+
+    @SuppressWarnings("unused")
+    static boolean useExplicitAddend(long addend) {
+        // For now, we are always using explicit addends
+        return true;
+    }
 }

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/elf/ELFProgbitsSection.java

@@ -69,7 +69,7 @@ public void setContent(byte[] c) {
     }
 
     @Override
-    public void markRelocationSite(int offset, ObjectFile.RelocationKind k, String symbolName, boolean useImplicitAddend, Long explicitAddend) {
-        markRelocationSite(offset, ByteBuffer.wrap(getContent()).order(getOwner().getByteOrder()), k, symbolName, useImplicitAddend, explicitAddend);
+    public void markRelocationSite(int offset, ObjectFile.RelocationKind k, String symbolName, long addend) {
+        markRelocationSite(offset, ByteBuffer.wrap(getContent()).order(getOwner().getByteOrder()), k, symbolName, addend);
     }
 }

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/elf/ELFRelocationSection.java

@@ -108,6 +108,19 @@ int getWrittenSize() {
 
     interface ELFRelocationMethod extends RelocationMethod {
 
+        /*
+         * For now, ELF relocations are always using explicit addends. This can change in the
+         * future.
+         */
+
+        default boolean canUseImplicitAddend() {
+            return false;
+        }
+
+        default boolean canUseExplicitAddend() {
+            return true;
+        }
+
         long toLong();
     }
 
@@ -172,24 +185,24 @@ public int hashCode() {
         }
     }
 
-    public Entry addEntry(ELFSection s, long offset, ELFRelocationMethod t, ELFSymtab.Entry sym, Long explicitAddend) {
-        if (explicitAddend != null) {
+    void addEntry(ELFSection s, long offset, ELFRelocationMethod t, ELFSymtab.Entry sym, long addend) {
+        if (ELFObjectFile.useExplicitAddend(addend)) {
             if (!t.canUseExplicitAddend()) {
                 throw new IllegalArgumentException("cannot use relocation method " + t + " with explicit addends");
             }
             if (!withExplicitAddends) {
                 throw new IllegalStateException("cannot create relocation with addend in .rel section");
             }
         } else {
+            // use implicit addend
             if (!t.canUseImplicitAddend()) {
                 throw new IllegalArgumentException("cannot use relocation method " + t + " with implicit addends");
             }
             if (withExplicitAddends) {
                 throw new IllegalStateException("cannot create relocation without addend in .rela section");
             }
         }
-        long addend = (explicitAddend != null) ? explicitAddend : 0L;
-        return entries.computeIfAbsent(new Entry(s, offset, t, sym, addend), Function.identity());
+        entries.computeIfAbsent(new Entry(s, offset, t, sym, addend), Function.identity());
     }
 
     public boolean isDynamic() {