RFR: 8325467: Support methods with many arguments in C2 [v4]

[Daniel Lundén]

On Wed, 4 Sep 2024 16:09:42 GMT, Vladimir Kozlov <kvn at openjdk.org> wrote:

>>> As we discussed on our previous meeting Aarch64 has very small registers mask - only 10 words. Can you look if that enough or we should increase static size of it? It could be separate RFE.
>> 
>> I do have looking at this in my to-do list (as a separate RFE). I'm not sure it is an issue though: the calculation of `RM_SIZE` first ensures that it covers all registers, and then adds three words to cover arguments, locks, and some other things. If it is only 10 words in total on aarch64, it should be because we simply do not have as many registers that we need to refer to. I do not recall from our discussion, is there some particular case where `RM_SIZE` on aarch64 is an issue?
>
>> is there some particular case where RM_SIZE on aarch64 is an issue?
> 
> Both `register_aarch64.hpp` and  `register_x86.hpp` (64-bits) specify  `number_of_registers  = 32`. So why `RM_SIZE` is different?

Thanks for the review @vnkozlov!

I just pushed an updated version. @dean: I believe the update addresses your concerns.

Summary of the most important changes:
- Add a (generous) limit to the number of stack slots that `BoxLockNode`s can occupy in total. If we reach the limit, we bail out of compilation.
- Add an upper bound for register mask growth. The upper bound is is (or, should be) impossible to reach, and I've added an `assert` to check this whenever a register mask grows.

          // Compute a best-effort (statically known) upper bound for register mask
          // size in 32-bit words. When extending/growing register masks, we should
          // never grow past this size.
          static const unsigned int RM_SIZE_MAX =
              (((RM_SIZE_MIN << 5) +                // Slots for machine registers
                (max_method_parameter_length * 2) + // Slots for incoming arguments
                (max_method_parameter_length * 2) + // Slots for outgoing arguments
                BoxLockNode_slot_limit +            // Slots for locks
                64                                  // Padding, reserved words, etc.
                ) + 31) >> 5; // Number of bits -> number of 32-bit words

- Add a `STATIC_ASSERT` that `short` can index the maximum size register mask.
- Add a compilation bailout to `PhaseChaitin::Select` at register mask chunk rollover, if `short` can no longer index the rolled-over mask.
- Require that the user provides the arena in which to extend register masks directly in register mask constructors. This is slightly more verbose compared to using `_comp_arena` by default, but safer and more flexible.
- Optimize memory consumption by allocating extensions of temporary register masks in a separate resource area (not `_comp_arena`).
- Add @robcasloz's register mask tests.
- Improve register mask dumping functionality (I needed it for debugging, could go in a separate RFE).
- Make `overlap` also take the `all-stack` flag into account (bug).
- Rename `TestManyMethodArguments.java` to `TestMaxMethodArguments.java`. It now tests that C2 can compile the maximum allowed number of arguments (according to the JVM spec).

-------------

PR Comment: https://git.openjdk.org/jdk/pull/20404#issuecomment-2337966119