RFR: 8347459: C2: missing transformation for chain of shifts/multiplications by constants

[Marc Chevalier]

This collapses double shift lefts by constants in a single constant: (x << con1) << con2 => x << (con1 + con2). Care must be taken in the case con1 + con2 is bigger than the number of bits in the integer type. In this case, we must simplify to 0.

Moreover, the simplification logic of the sign extension trick had to be improved. For instance, we use `(x << 16) >> 16` to convert a 32 bits into a 16 bits integer, with sign extension. When storing this into a 16-bit field, this can be simplified into simple `x`. But in the case where `x` is itself a left-shift expression, say `y << 3`, this PR makes the IR looks like `(y << 19) >> 16` instead of the old `((y << 3) << 16) >> 16`. The former logic didn't handle the case where the left and the right shift have different magnitude. In this PR, I generalize this simplification to cases where the left shift has a larger magnitude than the right shift. This improvement was needed not to miss vectorization opportunities: without the simplification, we have a left shift and a right shift instead of a single left shift, which confuses the type inference.

This also works for multiplications by powers of 2 since they are already translated into shifts.

Thanks,
Marc

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

Commit messages:
 - improve simplification of double shifts in stores
 - actually return a new node
 - format
 - fix type bug
 - clang-format
 - register for igvn
 - more tests
 - collapse lshift with constants

Changes: https://git.openjdk.org/jdk/pull/23728/files
  Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=23728&range=00
  Issue: https://bugs.openjdk.org/browse/JDK-8347459
  Stats: 272 lines in 5 files changed: 262 ins; 0 del; 10 mod
  Patch: https://git.openjdk.org/jdk/pull/23728.diff
  Fetch: git fetch https://git.openjdk.org/jdk.git pull/23728/head:pull/23728

PR: https://git.openjdk.org/jdk/pull/23728