commit 340097d0b50eff9d3058e06c6989ae398c653d4a

Author: Florian Weimer <fweimer@redhat.com>

Date:   Thu Sep 22 12:10:41 2022 +0200

    elf: Extract glibcelf constants from <elf.h>

    The need to maintain elf/elf.h and scripts/glibcelf.py in parallel

    results in a backporting hazard: they need to be kept in sync to

    avoid elf/tst-glibcelf consistency check failures.  glibcelf (unlike

    tst-glibcelf) does not use the C implementation to extract constants.

    This applies the additional glibcpp syntax checks to <elf.h>.

    This  changereplaces the types derived from Python enum types with

    custom types _TypedConstant, _IntConstant, and _FlagConstant.  These

    types have fewer safeguards, but this also allows incremental

    construction and greater flexibility for grouping constants among

    the types.  Architectures-specific named constants are now added

    as members into their superclasses (but value-based lookup is

    still restricted to generic constants only).

    Consequently, check_duplicates in elf/tst-glibcelf has been adjusted

    to accept differently-named constants of the same value if their

    subtypes are distinct.  The ordering check for named constants

    has been dropped because they are no longer strictly ordered.

    Further test adjustments: Some of the type names are different.

    The new types do not support iteration (because it is unclear

    whether iteration should cover the all named values (including

    architecture-specific constants), or only the generic named values),

    so elf/tst-glibcelf now uses by_name explicit (to get all constants).

    PF_HP_SBP and PF_PARISC_SBP are now of distinct types (PfHP and

    PfPARISC), so they are how both present on the Python side.  EM_NUM

    and PT_NUM are filtered (which was an oversight in the old

    conversion).

    The new version of glibcelf should also be compatible with earlier

    Python versions because it no longer depends on the enum module and its

    advanced features.

    Reviewed-by: Siddhesh Poyarekar <siddhesh@sourceware.org>

diff --git a/elf/tst-glibcelf.py b/elf/tst-glibcelf.py

index e5026e2289df206b..a5bff45eae55edea 100644

--- a/elf/tst-glibcelf.py

+++ b/elf/tst-glibcelf.py

@@ -18,7 +18,6 @@

 # <https://www.gnu.org/licenses/>.

 import argparse

-import enum

 import sys

 import glibcelf

@@ -45,11 +44,57 @@ def find_constant_prefix(name):

 def find_enum_types():

     """A generator for OpenIntEnum and IntFlag classes in glibcelf."""

+    classes = set((glibcelf._TypedConstant, glibcelf._IntConstant,

+                   glibcelf._FlagConstant))

     for obj in vars(glibcelf).values():

-        if isinstance(obj, type) and obj.__bases__[0] in (

-                glibcelf._OpenIntEnum, enum.Enum, enum.IntFlag):

+        if isinstance(obj, type) and obj not in classes \

+           and obj.__bases__[0] in classes:

             yield obj

+def check_basic():

+    """Check basic functionality of the constant classes."""

+

+    if glibcelf.Pt.PT_NULL is not glibcelf.Pt(0):

+        error('Pt(0) not interned')

+    if glibcelf.Pt(17609) is glibcelf.Pt(17609):

+        error('Pt(17609) unexpectedly interned')

+    if glibcelf.Pt(17609) == glibcelf.Pt(17609):

+        pass

+    else:

+        error('Pt(17609) equality')

+    if glibcelf.Pt(17610) == glibcelf.Pt(17609):

+        error('Pt(17610) equality')

+

+    if str(glibcelf.Pt.PT_NULL) != 'PT_NULL':

+        error('str(PT_NULL)')

+    if str(glibcelf.Pt(17609)) != '17609':

+        error('str(Pt(17609))')

+

+    if repr(glibcelf.Pt.PT_NULL) != 'PT_NULL':

+        error('repr(PT_NULL)')

+    if repr(glibcelf.Pt(17609)) != 'Pt(17609)':

+        error('repr(Pt(17609))')

+

+    if glibcelf.Pt('PT_AARCH64_MEMTAG_MTE') \

+       is not glibcelf.Pt.PT_AARCH64_MEMTAG_MTE:

+        error('PT_AARCH64_MEMTAG_MTE identity')

+    if glibcelf.Pt(0x70000002) is glibcelf.Pt.PT_AARCH64_MEMTAG_MTE:

+        error('Pt(0x70000002) identity')

+    if glibcelf.PtAARCH64(0x70000002) is not glibcelf.Pt.PT_AARCH64_MEMTAG_MTE:

+        error('PtAARCH64(0x70000002) identity')

+    if glibcelf.Pt.PT_AARCH64_MEMTAG_MTE.short_name != 'AARCH64_MEMTAG_MTE':

+        error('PT_AARCH64_MEMTAG_MTE short name')

+

+    # Special cases for int-like Shn.

+    if glibcelf.Shn(32) == glibcelf.Shn.SHN_XINDEX:

+        error('Shn(32)')

+    if glibcelf.Shn(32) + 0 != 32:

+        error('Shn(32) + 0')

+    if 32 in glibcelf.Shn:

+        error('32 in Shn')

+    if 0 not in glibcelf.Shn:

+        error('0 not in Shn')

+

 def check_duplicates():

     """Verifies that enum types do not have duplicate values.

@@ -59,17 +104,16 @@ def check_duplicates():

     global_seen = {}

     for typ in find_enum_types():

         seen = {}

-        last = None

-        for (name, e) in typ.__members__.items():

+        for (name, e) in typ.by_name.items():

             if e.value in seen:

-                error('{} has {}={} and {}={}'.format(

-                    typ, seen[e.value], e.value, name, e.value))

-                last = e

+                other = seen[e.value]

+                # Value conflicts only count if they are between

+                # the same base type.

+                if e.__class__ is typ and other.__class__ is typ:

+                    error('{} has {}={} and {}={}'.format(

+                        typ, other, e.value, name, e.value))

             else:

                 seen[e.value] = name

-                if last is not None and last.value > e.value:

-                    error('{} has {}={} after {}={}'.format(

-                        typ, name, e.value, last.name, last.value))

                 if name in global_seen:

                     error('{} used in {} and {}'.format(

                         name, global_seen[name], typ))

@@ -81,7 +125,7 @@ def check_constant_prefixes():

     seen = set()

     for typ in find_enum_types():

         typ_prefix = None

-        for val in typ:

+        for val in typ.by_name.values():

             prefix = find_constant_prefix(val.name)

             if prefix is None:

                 error('constant {!r} for {} has unknown prefix'.format(

@@ -113,7 +157,6 @@ def find_elf_h_constants(cc):

 # used in <elf.h>.

 glibcelf_skipped_aliases = (

     ('EM_ARC_A5', 'EM_ARC_COMPACT'),

-    ('PF_PARISC_SBP', 'PF_HP_SBP')

 )

 # Constants that provide little value and are not included in

@@ -146,6 +189,7 @@ DT_VALRNGLO

 DT_VERSIONTAGNUM

 ELFCLASSNUM

 ELFDATANUM

+EM_NUM

 ET_HIOS

 ET_HIPROC

 ET_LOOS

@@ -159,6 +203,7 @@ PT_HISUNW

 PT_LOOS

 PT_LOPROC

 PT_LOSUNW

+PT_NUM

 SHF_MASKOS

 SHF_MASKPROC

 SHN_HIOS

@@ -193,7 +238,7 @@ def check_constant_values(cc):

     """Checks the values of <elf.h> constants against glibcelf."""

     glibcelf_constants = {

-        e.name: e for typ in find_enum_types() for e in typ}

+        e.name: e for typ in find_enum_types() for e in typ.by_name.values()}

     elf_h_constants = find_elf_h_constants(cc=cc)

     missing_in_glibcelf = (set(elf_h_constants) - set(glibcelf_constants)

@@ -229,12 +274,13 @@ def check_constant_values(cc):

     for name in sorted(set(glibcelf_constants) & set(elf_h_constants)):

         glibcelf_value = glibcelf_constants[name].value

         elf_h_value = int(elf_h_constants[name])

-        # On 32-bit architectures <elf.h> as some constants that are

+        # On 32-bit architectures <elf.h> has some constants that are

         # parsed as signed, while they are unsigned in glibcelf.  So

         # far, this only affects some flag constants, so special-case

         # them here.

         if (glibcelf_value != elf_h_value

-            and not (isinstance(glibcelf_constants[name], enum.IntFlag)

+            and not (isinstance(glibcelf_constants[name],

+                                glibcelf._FlagConstant)

                      and glibcelf_value == 1 << 31

                      and elf_h_value == -(1 << 31))):

             error('{}: glibcelf has {!r}, <elf.h> has {!r}'.format(

@@ -266,6 +312,7 @@ def main():

                         help='C compiler (including options) to use')

     args = parser.parse_args()

+    check_basic()

     check_duplicates()

     check_constant_prefixes()

     check_constant_values(cc=args.cc)

diff --git a/scripts/glibcelf.py b/scripts/glibcelf.py

index 5c8f46f590722384..420cb21943b28bba 100644

--- a/scripts/glibcelf.py

+++ b/scripts/glibcelf.py

@@ -25,711 +25,445 @@ parsing it.

 """

 import collections

-import enum

+import functools

+import os

 import struct

-if not hasattr(enum, 'IntFlag'):

-    import sys

-    sys.stdout.write(

-        'warning: glibcelf.py needs Python 3.6 for enum support\n')

-    sys.exit(77)

+import glibcpp

+

+class _MetaNamedValue(type):

+    """Used to set up _NamedValue subclasses."""

-class _OpenIntEnum(enum.IntEnum):

-    """Integer enumeration that supports arbitrary int values."""

     @classmethod

-    def _missing_(cls, value):

-        # See enum.IntFlag._create_pseudo_member_.  This allows

-        # creating of enum constants with arbitrary integer values.

-        pseudo_member = int.__new__(cls, value)

-        pseudo_member._name_ = None

-        pseudo_member._value_ = value

-        return pseudo_member

+    def __prepare__(metacls, cls, bases, **kwds):

+        # Indicates an int-based class.  Needed for types like Shn.

+        int_based = False

+        for base in bases:

+            if issubclass(base, int):

+                int_based = int

+                break

+        return dict(by_value={},

+                    by_name={},

+                    prefix=None,

+                    _int_based=int_based)

-    def __repr__(self):

-        name = self._name_

-        if name is not None:

-            # The names have prefixes like SHT_, implying their type.

-            return name

-        return '{}({})'.format(self.__class__.__name__, self._value_)

+    def __contains__(self, other):

+        return other in self.by_value

+

+class _NamedValue(metaclass=_MetaNamedValue):

+    """Typed, named integer constants.

+

+    Constants have the following instance attributes:

+

+    name: The full name of the constant (e.g., "PT_NULL").

+    short_name: The name with of the constant without the prefix ("NULL").

+    value: The integer value of the constant.

+

+    The following class attributes are available:

+

+    by_value: A dict mapping integers to constants.

+    by_name: A dict mapping strings to constants.

+    prefix: A string that is removed from the start of short names, or None.

+

+    """

+

+    def __new__(cls, arg0, arg1=None):

+        """Instance creation.

+

+        For the one-argument form, the argument must be a string, an

+        int, or an instance of this class.  Strings are looked up via

+        by_name.  Values are looked up via by_value; if value lookup

+        fails, a new unnamed instance is returned.  Instances of this

+        class a re returned as-is.

+

+        The two-argument form expects the name (a string) and the

+        value (an integer).  A new instance is created in this case.

+        The instance is not registered in the by_value/by_name

+        dictionaries (but the caller can do that).

+

+        """

+

+        typ0 = type(arg0)

+        if arg1 is None:

+            if isinstance(typ0, cls):

+                # Re-use the existing object.

+                return arg0

+            if typ0 is int:

+                by_value = cls.by_value

+                try:

+                    return by_value[arg0]

+                except KeyError:

+                    # Create a new object of the requested value.

+                    if cls._int_based:

+                        result = int.__new__(cls, arg0)

+                    else:

+                        result = object.__new__(cls)

+                    result.value = arg0

+                    result.name = None

+                    return result

+            if typ0 is str:

+                by_name = cls.by_name

+                try:

+                    return by_name[arg0]

+                except KeyError:

+                    raise ValueError('unknown {} constant: {!r}'.format(

+                        cls.__name__, arg0))

+        else:

+            # Types for the two-argument form are rigid.

+            if typ0 is not str and typ0 is not None:

+                raise ValueError('type {} of name {!r} should be str'.format(

+                    typ0.__name__, arg0))

+            if type(arg1) is not int:

+                raise ValueError('type {} of value {!r} should be int'.format(

+                    type(arg1).__name__, arg1))

+            # Create a new named constants.

+            if cls._int_based:

+                result = int.__new__(cls, arg1)

+            else:

+                result = object.__new__(cls)

+            result.value = arg1

+            result.name = arg0

+            # Set up the short_name attribute.

+            prefix = cls.prefix

+            if prefix and arg0.startswith(prefix):

+                result.short_name = arg0[len(prefix):]

+            else:

+                result.short_name = arg0

+            return result

     def __str__(self):

-        name = self._name_

-        if name is not None:

+        name = self.name

+        if name:

+            return name

+        else:

+            return str(self.value)

+

+    def __repr__(self):

+        name = self.name

+        if name:

             return name

-        return str(self._value_)

+        else:

+            return '{}({})'.format(self.__class__.__name__, self.value)

+

+    def __setattr__(self, name, value):

+        # Prevent modification of the critical attributes once they

+        # have been set.

+        if name in ('name', 'value', 'short_name') and hasattr(self, name):

+            raise AttributeError('can\'t set attribute {}'.format(name))

+        object.__setattr__(self, name, value)

+

+@functools.total_ordering

+class _TypedConstant(_NamedValue):

+    """Base class for integer-valued optionally named constants.

+

+    This type is not an integer type.

+

+    """

+

+    def __eq__(self, other):

+        return isinstance(other, self.__class__) and self.value == other.value

+

+    def __lt__(self, other):

+        return isinstance(other, self.__class__) and self.value <= other.value

+

+    def __hash__(self):

+        return hash(self.value)

+

+class _IntConstant(_NamedValue, int):

+    """Base class for integer-like optionally named constants.

+

+    Instances compare equal to the integer of the same value, and can

+    be used in integer arithmetic.

+

+    """

-class ElfClass(_OpenIntEnum):

+    pass

+

+class _FlagConstant(_TypedConstant, int):

+    pass

+

+def _parse_elf_h():

+    """Read ../elf/elf.h and return a dict with the constants in it."""

+

+    path = os.path.join(os.path.dirname(os.path.realpath(__file__)),

+                        '..', 'elf', 'elf.h')

+    class TokenizerReporter:

+        """Report tokenizer errors to standard output."""

+

+        def __init__(self):

+            self.errors = 0

+

+        def error(self, token, message):

+            self.errors += 1

+            print('{}:{}:{}: error: {}'.format(

+                path, token.line, token.column, message))

+

+    reporter = TokenizerReporter()

+    with open(path) as inp:

+        tokens = glibcpp.tokenize_c(inp.read(), reporter)

+    if reporter.errors:

+        raise IOError('parse error in elf.h')

+

+    class MacroReporter:

+        """Report macro errors to standard output."""

+

+        def __init__(self):

+            self.errors = 0

+

+        def error(self, line, message):

+            errors += 1

+            print('{}:{}: error: {}'.format(path, line, message))

+

+        def note(self, line, message):

+            print('{}:{}: note: {}'.format(path, line, message))

+

+    reporter = MacroReporter()

+    result = glibcpp.macro_eval(glibcpp.macro_definitions(tokens), reporter)

+    if reporter.errors:

+        raise IOError('parse error in elf.h')

+

+    return result

+_elf_h = _parse_elf_h()

+del _parse_elf_h

+_elf_h_processed = set()

+

+def _register_elf_h(cls, prefix=None, skip=(), ranges=False, parent=None):

+    prefix = prefix or cls.prefix

+    if not prefix:

+        raise ValueError('missing prefix for {}'.format(cls.__name__))

+    by_value = cls.by_value

+    by_name = cls.by_name

+    processed = _elf_h_processed

+

+    skip = set(skip)

+    skip.add(prefix + 'NUM')

+    if ranges:

+        skip.add(prefix + 'LOOS')

+        skip.add(prefix + 'HIOS')

+        skip.add(prefix + 'LOPROC')

+        skip.add(prefix + 'HIPROC')

+        cls.os_range = (_elf_h[prefix + 'LOOS'], _elf_h[prefix + 'HIOS'])

+        cls.proc_range = (_elf_h[prefix + 'LOPROC'], _elf_h[prefix + 'HIPROC'])

+

+    # Inherit the prefix from the parent if not set.

+    if parent and cls.prefix is None and parent.prefix is not None:

+        cls.prefix = parent.prefix

+

+    processed_len_start = len(processed)

+    for name, value in _elf_h.items():

+        if name in skip or name in processed:

+            continue

+        if name.startswith(prefix):

+            processed.add(name)

+            if value in by_value:

+                raise ValueError('duplicate value {}: {}, {}'.format(

+                    value, name, by_value[value]))

+            obj = cls(name, value)

+            by_value[value] = obj

+            by_name[name] = obj

+            setattr(cls, name, obj)

+            if parent:

+                # Make the symbolic name available through the parent as well.

+                parent.by_name[name] = obj

+                setattr(parent, name, obj)

+

+    if len(processed) == processed_len_start:

+        raise ValueError('nothing matched prefix {!r}'.format(prefix))

+

+class ElfClass(_TypedConstant):

     """ELF word size.  Type of EI_CLASS values."""

-    ELFCLASSNONE = 0

-    ELFCLASS32 = 1

-    ELFCLASS64 = 2

+_register_elf_h(ElfClass, prefix='ELFCLASS')

-class ElfData(_OpenIntEnum):

+class ElfData(_TypedConstant):

     """ELF endianess.  Type of EI_DATA values."""

-    ELFDATANONE = 0

-    ELFDATA2LSB = 1

-    ELFDATA2MSB = 2

+_register_elf_h(ElfData, prefix='ELFDATA')

-class Machine(_OpenIntEnum):

+class Machine(_TypedConstant):

     """ELF machine type.  Type of values in Ehdr.e_machine field."""

-    EM_NONE = 0

-    EM_M32 = 1

-    EM_SPARC = 2

-    EM_386 = 3

-    EM_68K = 4

-    EM_88K = 5

-    EM_IAMCU = 6

-    EM_860 = 7

-    EM_MIPS = 8

-    EM_S370 = 9

-    EM_MIPS_RS3_LE = 10

-    EM_PARISC = 15

-    EM_VPP500 = 17

-    EM_SPARC32PLUS = 18

-    EM_960 = 19

-    EM_PPC = 20

-    EM_PPC64 = 21

-    EM_S390 = 22

-    EM_SPU = 23

-    EM_V800 = 36

-    EM_FR20 = 37

-    EM_RH32 = 38

-    EM_RCE = 39

-    EM_ARM = 40

-    EM_FAKE_ALPHA = 41

-    EM_SH = 42

-    EM_SPARCV9 = 43

-    EM_TRICORE = 44

-    EM_ARC = 45

-    EM_H8_300 = 46

-    EM_H8_300H = 47

-    EM_H8S = 48

-    EM_H8_500 = 49

-    EM_IA_64 = 50

-    EM_MIPS_X = 51

-    EM_COLDFIRE = 52

-    EM_68HC12 = 53

-    EM_MMA = 54

-    EM_PCP = 55

-    EM_NCPU = 56

-    EM_NDR1 = 57

-    EM_STARCORE = 58

-    EM_ME16 = 59

-    EM_ST100 = 60

-    EM_TINYJ = 61

-    EM_X86_64 = 62

-    EM_PDSP = 63

-    EM_PDP10 = 64

-    EM_PDP11 = 65

-    EM_FX66 = 66

-    EM_ST9PLUS = 67

-    EM_ST7 = 68

-    EM_68HC16 = 69

-    EM_68HC11 = 70

-    EM_68HC08 = 71

-    EM_68HC05 = 72

-    EM_SVX = 73

-    EM_ST19 = 74

-    EM_VAX = 75

-    EM_CRIS = 76

-    EM_JAVELIN = 77

-    EM_FIREPATH = 78

-    EM_ZSP = 79

-    EM_MMIX = 80

-    EM_HUANY = 81

-    EM_PRISM = 82

-    EM_AVR = 83

-    EM_FR30 = 84

-    EM_D10V = 85

-    EM_D30V = 86

-    EM_V850 = 87

-    EM_M32R = 88

-    EM_MN10300 = 89

-    EM_MN10200 = 90

-    EM_PJ = 91

-    EM_OPENRISC = 92

-    EM_ARC_COMPACT = 93

-    EM_XTENSA = 94

-    EM_VIDEOCORE = 95

-    EM_TMM_GPP = 96

-    EM_NS32K = 97

-    EM_TPC = 98

-    EM_SNP1K = 99

-    EM_ST200 = 100

-    EM_IP2K = 101

-    EM_MAX = 102

-    EM_CR = 103

-    EM_F2MC16 = 104

-    EM_MSP430 = 105

-    EM_BLACKFIN = 106

-    EM_SE_C33 = 107

-    EM_SEP = 108

-    EM_ARCA = 109

-    EM_UNICORE = 110

-    EM_EXCESS = 111

-    EM_DXP = 112

-    EM_ALTERA_NIOS2 = 113

-    EM_CRX = 114

-    EM_XGATE = 115

-    EM_C166 = 116

-    EM_M16C = 117

-    EM_DSPIC30F = 118

-    EM_CE = 119

-    EM_M32C = 120

-    EM_TSK3000 = 131

-    EM_RS08 = 132

-    EM_SHARC = 133

-    EM_ECOG2 = 134

-    EM_SCORE7 = 135

-    EM_DSP24 = 136

-    EM_VIDEOCORE3 = 137

-    EM_LATTICEMICO32 = 138

-    EM_SE_C17 = 139

-    EM_TI_C6000 = 140

-    EM_TI_C2000 = 141

-    EM_TI_C5500 = 142

-    EM_TI_ARP32 = 143

-    EM_TI_PRU = 144

-    EM_MMDSP_PLUS = 160

-    EM_CYPRESS_M8C = 161

-    EM_R32C = 162

-    EM_TRIMEDIA = 163

-    EM_QDSP6 = 164

-    EM_8051 = 165

-    EM_STXP7X = 166

-    EM_NDS32 = 167

-    EM_ECOG1X = 168

-    EM_MAXQ30 = 169

-    EM_XIMO16 = 170

-    EM_MANIK = 171

-    EM_CRAYNV2 = 172

-    EM_RX = 173

-    EM_METAG = 174

-    EM_MCST_ELBRUS = 175

-    EM_ECOG16 = 176

-    EM_CR16 = 177

-    EM_ETPU = 178

-    EM_SLE9X = 179

-    EM_L10M = 180

-    EM_K10M = 181

-    EM_AARCH64 = 183

-    EM_AVR32 = 185

-    EM_STM8 = 186

-    EM_TILE64 = 187

-    EM_TILEPRO = 188

-    EM_MICROBLAZE = 189

-    EM_CUDA = 190

-    EM_TILEGX = 191

-    EM_CLOUDSHIELD = 192

-    EM_COREA_1ST = 193

-    EM_COREA_2ND = 194

-    EM_ARCV2 = 195

-    EM_OPEN8 = 196

-    EM_RL78 = 197

-    EM_VIDEOCORE5 = 198

-    EM_78KOR = 199

-    EM_56800EX = 200

-    EM_BA1 = 201

-    EM_BA2 = 202

-    EM_XCORE = 203

-    EM_MCHP_PIC = 204

-    EM_INTELGT = 205

-    EM_KM32 = 210

-    EM_KMX32 = 211

-    EM_EMX16 = 212

-    EM_EMX8 = 213

-    EM_KVARC = 214

-    EM_CDP = 215

-    EM_COGE = 216

-    EM_COOL = 217

-    EM_NORC = 218

-    EM_CSR_KALIMBA = 219

-    EM_Z80 = 220

-    EM_VISIUM = 221

-    EM_FT32 = 222

-    EM_MOXIE = 223

-    EM_AMDGPU = 224

-    EM_RISCV = 243

-    EM_BPF = 247

-    EM_CSKY = 252

-    EM_LOONGARCH = 258

-    EM_NUM = 259

-    EM_ALPHA = 0x9026

-

-class Et(_OpenIntEnum):

+    prefix = 'EM_'

+_register_elf_h(Machine, skip=('EM_ARC_A5',))

+

+class Et(_TypedConstant):

     """ELF file type.  Type of ET_* values and the Ehdr.e_type field."""

-    ET_NONE = 0

-    ET_REL = 1

-    ET_EXEC = 2

-    ET_DYN = 3

-    ET_CORE = 4

+    prefix = 'ET_'

+_register_elf_h(Et, ranges=True)

-class Shn(_OpenIntEnum):

+class Shn(_IntConstant):

     """ELF reserved section indices."""

-    SHN_UNDEF = 0

-    SHN_BEFORE = 0xff00

-    SHN_AFTER = 0xff01

-    SHN_ABS = 0xfff1

-    SHN_COMMON = 0xfff2

-    SHN_XINDEX = 0xffff

-

-class ShnMIPS(enum.Enum):

+    prefix = 'SHN_'

+class ShnMIPS(Shn):

     """Supplemental SHN_* constants for EM_MIPS."""

-    SHN_MIPS_ACOMMON = 0xff00

-    SHN_MIPS_TEXT = 0xff01

-    SHN_MIPS_DATA = 0xff02

-    SHN_MIPS_SCOMMON = 0xff03

-    SHN_MIPS_SUNDEFINED = 0xff04

-

-class ShnPARISC(enum.Enum):