`out of range pc-relative fixup value` on arm32

[kraj]

This is seen with clang-19, does not happen with clang-18, attached program when compiled with -O2 exhibits the problem, other -O options are ok.

In file included from /mnt/b/yoe/master/build/tmp/work/cortexa15t2hf-neon-yoe-linux-gnueabi/libjxl/0.10.3/git/lib/jxl/enc_ar_control_field.cc:1:                                                        │
│In file included from <built-in>:452:                                                                                                                                                                   │
│<command line>:4:9: warning: redefining builtin macro [-Wbuiltin-macro-redefined]                                                                                                                       │
│    4 | #define __DATE__ "redacted"                                                                                                                                                                     │
│      |         ^                                                                                                                                                                                       │
│<command line>:5:9: warning: redefining builtin macro [-Wbuiltin-macro-redefined]                                                                                                                       │
│    5 | #define __TIMESTAMP__ "redacted"                                                                                                                                                                │
│      |         ^                                                                                                                                                                                       │
│<command line>:6:9: warning: redefining builtin macro [-Wbuiltin-macro-redefined]                                                                                                                       │
│    6 | #define __TIME__ "redacted"                                                                                                                                                                     │
│      |         ^                                                                                                                                                                                       │
│error: out of range pc-relative fixup value                                                                                                                                                             │
│3 warnings and 1 error generated.                                                                                                                                                                       │

pc-relative.zip

[Endilll]

I was able to reliably reproduce this locally using Clang 19, but for whatever reason, I can't get it to work on Compiler Explorer, despite using exactly the same binaries. @kraj can you try Clang 20? I can't reproduce this on trunk.

Reduce by me and C-Reduce:

# 0 "" 3
struct Status {
  Status(int);
};

struct RectT {};
RectT rect;

struct Image3 {
  float *ConstPlaneRow(int);
  int xsize();
};

void FillPlane(int, RectT);

struct Vec128 {
  float raw[4];
};

Vec128 Add(Vec128 a, Vec128 b) {
  for (int i = 0; i < 4; ++i)
    a.raw[0] += b.raw[i];
  return a;
}

Vec128 Mul(Vec128 a, Vec128 b) {
  for (int i = 0; i < 4; ++i)
    a.raw[0] *= b.raw[0];
  return a;
}

Vec128 MulAdd_mul;

Vec128 MulAdd(Vec128 x, Vec128 add) {
  return Add(Mul(MulAdd_mul, x), add);
}

void StoreU(Vec128, int, int);

float *in_row_b[0];
float *in_row_T[0];
float in_row_b_1_0;
float in_row_0_0;
int kChannelWeightsLapNeg[0];
int CopyBytesFromI;
int CopyBytesFromI2;
void *CopyBytesFromV;
int laplacian_sqrsum_row;
int x0;
int distance;
int sumsqr;
Vec128 __trans_tmp_26;
Vec128 sum_oth1;

Status ProcessTile(int &epf_iters) {
  Image3 opsin;
  Vec128 __trans_tmp_23;
  if (distance || epf_iters) {
    FillPlane(0, rect);
    return;
  }
  while (x0) {
    for (int c = 0; c < 3; c++)
      in_row_T[0] = in_row_b[0] = opsin.ConstPlaneRow(0);
    auto compute_laplacian_scalar = [&] {
      int nextX = opsin.xsize();
      for (int c = 0; c < 3; c++) {
        float laplacian =
            0 + kChannelWeightsLapNeg[c] * in_row_0_0 +
            in_row_b_1_0 + in_row_b[0][0] +
            in_row_b[c][nextX] + 0 + 1 +
            in_row_T[c][nextX];
        sumsqr += laplacian;
      }
      laplacian_sqrsum_row = 0;
    };
    for (; x0 < 0; x0++)
      compute_laplacian_scalar();
    while (opsin.xsize()) {
      Vec128 sumsqr;
      for (int c = 0; c < 3; c++) {
        Vec128 laplacian;
        Vec128 sum_oth0;
        Vec128 sum_oth2;
        __builtin_memcpy(sum_oth2.raw, (int *)1, 16);
        Vec128 sum_oth3 = __trans_tmp_23;
        Status(0);
        Vec128 v;
        __builtin_memcpy(v.raw, &CopyBytesFromI, 16);
        __trans_tmp_23 = v;
        Vec128 v_b;
        __builtin_memcpy(v_b.raw, &CopyBytesFromI2, 16);
        Vec128 v_b_c;
        __builtin_memcpy(v_b_c.raw, CopyBytesFromV, 16);
        sum_oth0 = Add(sum_oth1, v);
        sum_oth2 = Add(sum_oth2, v_b);
        sum_oth3 = Add(sum_oth3, v_b_c);
        sum_oth0 = Add(sum_oth0, sum_oth1);
        sum_oth2 = Add(sum_oth2, sum_oth3);
        sum_oth0 = Add(sum_oth0, sum_oth2);
        laplacian = MulAdd(sum_oth0, __trans_tmp_26);
        sumsqr = MulAdd(laplacian, sumsqr);
      }
      StoreU(sumsqr, 0, 0);
    }
  }
  0 <= opsin.xsize() ?: opsin.xsize();
  return 0;
}

Driver arguments: -target arm-yoe-linux-gnueabi -mthumb -mfpu=neon -mfloat-abi=hard -mcpu=cortex-a15 -mlittle-endian -fstack-protector-strong -O2 -Xclang -mrelax-all -fno-omit-frame-pointer -fno-slp-vectorize.
Frontend arguments: -cc1 -triple thumbv7-yoe-linux-gnueabihf -emit-obj -mframe-pointer=all -ffp-contract=on -target-cpu cortex-a15 -O2 -stack-protector 2 -vectorize-loops -mrelax-all.

[llvmbot]

@llvm/issue-subscribers-backend-arm

Author: Khem Raj (kraj)

This is seen with clang-19, does not happen with clang-18, attached program when compiled with -O2 exhibits the problem, other -O<n> options are ok.

In file included from /mnt/b/yoe/master/build/tmp/work/cortexa15t2hf-neon-yoe-linux-gnueabi/libjxl/0.10.3/git/lib/jxl/enc_ar_control_field.cc:1:                                                        │
│In file included from <built-in>:452:                                                                                                                                                                   │
│<command line>:4:9: warning: redefining builtin macro [-Wbuiltin-macro-redefined]                                                                                                                       │
│    4 | #define __DATE__ "redacted"                                                                                                                                                                     │
│      |         ^                                                                                                                                                                                       │
│<command line>:5:9: warning: redefining builtin macro [-Wbuiltin-macro-redefined]                                                                                                                       │
│    5 | #define __TIMESTAMP__ "redacted"                                                                                                                                                                │
│      |         ^                                                                                                                                                                                       │
│<command line>:6:9: warning: redefining builtin macro [-Wbuiltin-macro-redefined]                                                                                                                       │
│    6 | #define __TIME__ "redacted"                                                                                                                                                                     │
│      |         ^                                                                                                                                                                                       │
│error: out of range pc-relative fixup value                                                                                                                                                             │
│3 warnings and 1 error generated.                                                                                                                                                                       │

pc-relative.zip

[davemgreen]

It looks like the example above will fail if it uses output-to-assembly: https://godbolt.org/z/Pf3fEEf1z

From the look of https://maskray.me/blog/2024-04-27-clang-o0-output-branch-displacement-and-size-increase and #90013 (comment) / 8ad092f, -mrelax-all might have been ignored in the past, prior to clang-19 for most targets. (@MaskRay FYI, not sure if I got those details correct).

That option does not sound compatible with Arm if it happens late in the pipeline as instruction should not be relaxed from t1->t2 (or otherwise increase in size) after the ARMConstantIslandPass. Handling would need to be added to ARMConstantIslandPass if it was to be properly supported.

Do you know why the option is used, and can it just be removed from the command line?

[Endilll]

It looks like the example above will fail if it uses output-to-assembly: https://godbolt.org/z/Pf3fEEf1z

Indeed it does. I can confirm the issue on Clang 20, but not on trunk: https://godbolt.org/z/4W6adesdq
That said, I don't trust myself to hold it right.