Add additional check for custom array/hash access checking

PL_check[] can have customized checks for array/hash elements in the
OP_AELEM, OP_EXISTS, and OP_DELETE elements.  When these are set, the
multideref optimization is turned off.

It turns out that checking for this always shows that they are not the
standard values on z/OS, because that platform's function pointers may
point to a "function descriptor" and not the actual function, or it may
not.  It's not clear to me if this implementation conforms to the C
Standard or not, but it is what it is.  As a result our test suite fails
some tests that are expecting non-custom entries in those slots.

This commit builds upon some ideas from Dave Mitchell and Richard Leach
to add 3 entries to the array of function pointers.  These entries are
initialized the same way the others are, so that a comparison against
them when no customization has been done should succeed.

The current comparisons are retained, so that it's likely on z/OS one or
the other will succeed when no customization is currently in place.

Author: khwilliamson

opcode.h

@@ -2203,16 +2203,20 @@ S_maybe_multideref(pTHX_ OP *start, OP *orig_o, UV orig_action, U8 hints)
              * OP_EXISTS or OP_DELETE */
 
             /* if a custom array/hash access checker is in scope,
-             * abandon optimisation attempt */
+             * abandon optimisation attempt.  Check two different ways because
+             * of z/OS (see comments in opcode.h) */
             if (  (o->op_type == OP_AELEM || o->op_type == OP_HELEM)
-               && PL_check[o->op_type] != Perl_ck_null)
+               && PL_check[o->op_type] != Perl_ck_null
+               && PL_check[o->op_type] != PL_check[PERL_CK_NULL])
                 return;
             /* similarly for customised exists and delete */
             if (  (o->op_type == OP_EXISTS)
-               && PL_check[o->op_type] != Perl_ck_exists)
+               && PL_check[o->op_type] != Perl_ck_exists
+               && PL_check[o->op_type] != PL_check[PERL_CK_EXISTS])
                 return;
             if (  (o->op_type == OP_DELETE)
-               && PL_check[o->op_type] != Perl_ck_delete)
+               && PL_check[o->op_type] != Perl_ck_delete
+               && PL_check[o->op_type] != PL_check[PERL_CK_DELETE])
                 return;
 
             if (   o->op_type != OP_AELEM

peep.c

@@ -1114,13 +1114,39 @@ sub generate_opcode_h_pl_check {
     INIT({
     END
 
+
     for (@ops) {
         print "\t", tab(3, "Perl_$check{$_},"), "\t/* $_ */\n";
     }
 
+    print <<~'END';
+
+    /* The final entries are function pointers not attached to an opcode.
+     * These are used to compare with function pointers in the earlier part of
+     * the array, since in some platforms (notably z/OS), it is undefined
+     * behavior to compare function pointers for equality, even though calling
+     * them will invoke the same function.  This minimizes the risk of them
+     * being different by initializing them to the same values in the same
+     * array. */
+    END
+    my @perl_internal_extras = qw(ck_null ck_exists ck_delete);
+    for (@perl_internal_extras) {
+        print "\t", tab(3, "Perl_$_,\n");
+    }
+
     print <<~'END';
     });
+
+    /* Indexes into PL_check for the comparison function pointers */
+    #ifdef PERL_IN_PEEP_C
     END
+
+    for (my $i = 0; $i < @perl_internal_extras; $i++) {
+        my $index = @ops + $i;
+        my $define = uc $perl_internal_extras[$i];
+        print "  #define PERL_$define  $index\n";
+    }
+    print "#endif\n";
 }
 
 sub generate_opcode_h_pl_opargs {