starting build "79750138-f41e-4f39-8812-7c536f1d2e35" FETCHSOURCE BUILD Starting Step #0 Step #0: Already have image (with digest): gcr.io/cloud-builders/git Step #0: Cloning into 'oss-fuzz'... Finished Step #0 Starting Step #1 Step #1: Already have image (with digest): gcr.io/cloud-builders/docker Step #1: Sending build context to Docker daemon 5.12kB Step #1: Step 1/5 : FROM gcr.io/oss-fuzz-base/base-builder Step #1: latest: Pulling from oss-fuzz-base/base-builder Step #1: 4007a89234b4: Pulling fs layer Step #1: 5dfa26c6b9c9: Pulling fs layer Step #1: 0ba7bf18aa40: Pulling fs layer Step #1: 4c6ec688ebe3: Pulling fs layer Step #1: 932d61ab5fb0: Pulling fs layer Step #1: 94c06df03741: Pulling fs layer Step #1: 52cd3bf33643: Pulling fs layer Step #1: 4f486d1938e4: Pulling fs layer Step #1: 178010bacf69: Pulling fs layer Step #1: 7f3110f587fa: Pulling fs layer Step #1: c0fd0111425f: Pulling fs layer Step #1: 71b6a0e6a4cf: Pulling fs layer Step #1: 158c0c805071: Pulling fs layer Step #1: 5d145ded06e8: Pulling fs layer Step #1: 612350c6b9d5: Pulling fs layer Step #1: d50f8b26ce6b: Pulling fs layer Step #1: ba999baff7b6: Pulling fs layer Step #1: c73422a97a41: Pulling fs layer Step #1: 3decf2455dab: Pulling fs layer Step #1: ca63d9f4c6c9: Pulling fs layer Step #1: 44079d0d57ef: Pulling fs layer Step #1: ef2340c6e37a: Pulling fs layer Step #1: 62f04f5dca30: Pulling fs layer Step #1: 7e13d4e41bf4: Pulling fs layer Step #1: 5c9d262e30ab: Pulling fs layer Step #1: 10f8e2e4b112: Pulling fs layer Step #1: 178010bacf69: Waiting Step #1: 4c6ec688ebe3: Waiting Step #1: 932d61ab5fb0: Waiting Step #1: 158c0c805071: Waiting Step #1: 7f3110f587fa: Waiting Step #1: 4f486d1938e4: Waiting Step #1: 5d145ded06e8: Waiting Step #1: 612350c6b9d5: Waiting Step #1: 71b6a0e6a4cf: Waiting Step #1: c0fd0111425f: Waiting Step #1: 44079d0d57ef: Waiting Step #1: 7e13d4e41bf4: Waiting Step #1: 5c9d262e30ab: Waiting Step #1: 10f8e2e4b112: Waiting Step #1: 3decf2455dab: Waiting Step #1: ca63d9f4c6c9: Waiting Step #1: d50f8b26ce6b: Waiting Step #1: c73422a97a41: Waiting Step #1: ba999baff7b6: Waiting Step #1: 0ba7bf18aa40: Download complete Step #1: 5dfa26c6b9c9: Verifying Checksum Step #1: 5dfa26c6b9c9: Download complete Step #1: 4c6ec688ebe3: Verifying Checksum Step #1: 4c6ec688ebe3: Download complete Step #1: 94c06df03741: Verifying Checksum Step #1: 94c06df03741: Download complete Step #1: 4007a89234b4: Verifying Checksum Step #1: 4007a89234b4: Download complete Step #1: 932d61ab5fb0: Verifying Checksum Step #1: 932d61ab5fb0: Download complete Step #1: 4f486d1938e4: Verifying Checksum Step #1: 4f486d1938e4: Download complete Step #1: 7f3110f587fa: Download complete Step #1: 52cd3bf33643: Verifying Checksum Step #1: 52cd3bf33643: Download complete Step #1: 71b6a0e6a4cf: Download complete Step #1: 158c0c805071: Verifying Checksum Step #1: 158c0c805071: Download complete Step #1: c0fd0111425f: Verifying Checksum Step #1: c0fd0111425f: Download complete Step #1: 4007a89234b4: Pull complete Step #1: 5dfa26c6b9c9: Pull complete Step #1: 0ba7bf18aa40: Pull complete Step #1: 612350c6b9d5: Verifying Checksum Step #1: 612350c6b9d5: Download complete Step #1: 4c6ec688ebe3: Pull complete Step #1: 5d145ded06e8: Verifying Checksum Step #1: 5d145ded06e8: Download complete Step #1: ba999baff7b6: Verifying Checksum Step #1: ba999baff7b6: Download complete Step #1: c73422a97a41: Download complete Step #1: 3decf2455dab: Verifying Checksum Step #1: 3decf2455dab: Download complete Step #1: ca63d9f4c6c9: Verifying Checksum Step #1: ca63d9f4c6c9: Download complete Step #1: 932d61ab5fb0: Pull complete Step #1: d50f8b26ce6b: Verifying Checksum Step #1: d50f8b26ce6b: Download complete Step #1: 94c06df03741: Pull complete Step #1: ef2340c6e37a: Verifying Checksum Step #1: ef2340c6e37a: Download complete Step #1: 62f04f5dca30: Verifying Checksum Step #1: 62f04f5dca30: Download complete Step #1: 7e13d4e41bf4: Download complete Step #1: 5c9d262e30ab: Verifying Checksum Step #1: 5c9d262e30ab: Download complete Step #1: 44079d0d57ef: Verifying Checksum Step #1: 44079d0d57ef: Download complete Step #1: 10f8e2e4b112: Verifying Checksum Step #1: 10f8e2e4b112: Download complete Step #1: 178010bacf69: Verifying Checksum Step #1: 178010bacf69: Download complete Step #1: 52cd3bf33643: Pull complete Step #1: 4f486d1938e4: Pull complete Step #1: 178010bacf69: Pull complete Step #1: 7f3110f587fa: Pull complete Step #1: c0fd0111425f: Pull complete Step #1: 71b6a0e6a4cf: Pull complete Step #1: 158c0c805071: Pull complete Step #1: 5d145ded06e8: Pull complete Step #1: 612350c6b9d5: Pull complete Step #1: d50f8b26ce6b: Pull complete Step #1: ba999baff7b6: Pull complete Step #1: c73422a97a41: Pull complete Step #1: 3decf2455dab: Pull complete Step #1: ca63d9f4c6c9: Pull complete Step #1: 44079d0d57ef: Pull complete Step #1: ef2340c6e37a: Pull complete Step #1: 62f04f5dca30: Pull complete Step #1: 7e13d4e41bf4: Pull complete Step #1: 5c9d262e30ab: Pull complete Step #1: 10f8e2e4b112: Pull complete Step #1: Digest: sha256:7c5a3bb6dc08e23dba81c1f61b7158d7dcc43726d41f8a6cae24138d0279b0fa Step #1: Status: Downloaded newer image for gcr.io/oss-fuzz-base/base-builder:latest Step #1: ---> 5353c8aac6fa Step #1: Step 2/5 : RUN apt-get update && apt-get install -y build-essential cmake curl e2fsprogs libmpfr-dev libmpc-dev libgmp-dev ninja-build Step #1: ---> Running in fc2330e13cce Step #1: Hit:1 http://ppa.launchpad.net/git-core/ppa/ubuntu xenial InRelease Step #1: Get:2 http://security.ubuntu.com/ubuntu xenial-security InRelease [109 kB] Step #1: Hit:3 http://archive.ubuntu.com/ubuntu xenial InRelease Step #1: Get:4 http://archive.ubuntu.com/ubuntu xenial-updates InRelease [109 kB] Step #1: Get:5 http://archive.ubuntu.com/ubuntu xenial-backports InRelease [107 kB] Step #1: Fetched 325 kB in 0s (414 kB/s) Step #1: Reading package lists... Step #1: Reading package lists... Step #1: Building dependency tree... Step #1: Reading state information... Step #1: build-essential is already the newest version (12.1ubuntu2). Step #1: curl is already the newest version (7.47.0-1ubuntu2.18). Step #1: e2fsprogs is already the newest version (1.42.13-1ubuntu1.2). Step #1: The following additional packages will be installed: Step #1: cmake-data libarchive13 libcurl3 libgmpxx4ldbl libjsoncpp1 liblzo2-2 Step #1: Suggested packages: Step #1: codeblocks eclipse lrzip gmp-doc libgmp10-doc libmpfr-doc Step #1: The following NEW packages will be installed: Step #1: cmake cmake-data libarchive13 libcurl3 libgmp-dev libgmpxx4ldbl libjsoncpp1 Step #1: liblzo2-2 libmpc-dev libmpfr-dev ninja-build Step #1: 0 upgraded, 11 newly installed, 0 to remove and 0 not upgraded. Step #1: Need to get 4971 kB of archives. Step #1: After this operation, 25.3 MB of additional disk space will be used. Step #1: Get:1 http://archive.ubuntu.com/ubuntu xenial-updates/main amd64 cmake-data all 3.5.1-1ubuntu3 [1121 kB] Step #1: Get:2 http://archive.ubuntu.com/ubuntu xenial/main amd64 liblzo2-2 amd64 2.08-1.2 [48.7 kB] Step #1: Get:3 http://archive.ubuntu.com/ubuntu xenial-updates/main amd64 libarchive13 amd64 3.1.2-11ubuntu0.16.04.8 [262 kB] Step #1: Get:4 http://archive.ubuntu.com/ubuntu xenial-updates/main amd64 libcurl3 amd64 7.47.0-1ubuntu2.18 [187 kB] Step #1: Get:5 http://archive.ubuntu.com/ubuntu xenial/main amd64 libjsoncpp1 amd64 1.7.2-1 [73.0 kB] Step #1: Get:6 http://archive.ubuntu.com/ubuntu xenial-updates/main amd64 cmake amd64 3.5.1-1ubuntu3 [2623 kB] Step #1: Get:7 http://archive.ubuntu.com/ubuntu xenial/main amd64 libgmpxx4ldbl amd64 2:6.1.0+dfsg-2 [8948 B] Step #1: Get:8 http://archive.ubuntu.com/ubuntu xenial/main amd64 libgmp-dev amd64 2:6.1.0+dfsg-2 [314 kB] Step #1: Get:9 http://archive.ubuntu.com/ubuntu xenial/main amd64 libmpfr-dev amd64 3.1.4-1 [202 kB] Step #1: Get:10 http://archive.ubuntu.com/ubuntu xenial/universe amd64 ninja-build amd64 1.5.1-0.1ubuntu1 [84.8 kB] Step #1: Get:11 http://archive.ubuntu.com/ubuntu xenial/main amd64 libmpc-dev amd64 1.0.3-1 [48.0 kB] Step #1: debconf: delaying package configuration, since apt-utils is not installed Step #1: Fetched 4971 kB in 1s (4183 kB/s) Step #1: Selecting previously unselected package cmake-data. Step #1: (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 17482 files and directories currently installed.) Step #1: Preparing to unpack .../cmake-data_3.5.1-1ubuntu3_all.deb ... Step #1: Unpacking cmake-data (3.5.1-1ubuntu3) ... Step #1: Selecting previously unselected package liblzo2-2:amd64. Step #1: Preparing to unpack .../liblzo2-2_2.08-1.2_amd64.deb ... Step #1: Unpacking liblzo2-2:amd64 (2.08-1.2) ... Step #1: Selecting previously unselected package libarchive13:amd64. Step #1: Preparing to unpack .../libarchive13_3.1.2-11ubuntu0.16.04.8_amd64.deb ... Step #1: Unpacking libarchive13:amd64 (3.1.2-11ubuntu0.16.04.8) ... Step #1: Selecting previously unselected package libcurl3:amd64. Step #1: Preparing to unpack .../libcurl3_7.47.0-1ubuntu2.18_amd64.deb ... Step #1: Unpacking libcurl3:amd64 (7.47.0-1ubuntu2.18) ... Step #1: Selecting previously unselected package libjsoncpp1:amd64. Step #1: Preparing to unpack .../libjsoncpp1_1.7.2-1_amd64.deb ... Step #1: Unpacking libjsoncpp1:amd64 (1.7.2-1) ... Step #1: Selecting previously unselected package cmake. Step #1: Preparing to unpack .../cmake_3.5.1-1ubuntu3_amd64.deb ... Step #1: Unpacking cmake (3.5.1-1ubuntu3) ... Step #1: Selecting previously unselected package libgmpxx4ldbl:amd64. Step #1: Preparing to unpack .../libgmpxx4ldbl_2%3a6.1.0+dfsg-2_amd64.deb ... Step #1: Unpacking libgmpxx4ldbl:amd64 (2:6.1.0+dfsg-2) ... Step #1: Selecting previously unselected package libgmp-dev:amd64. Step #1: Preparing to unpack .../libgmp-dev_2%3a6.1.0+dfsg-2_amd64.deb ... Step #1: Unpacking libgmp-dev:amd64 (2:6.1.0+dfsg-2) ... Step #1: Selecting previously unselected package libmpfr-dev:amd64. Step #1: Preparing to unpack .../libmpfr-dev_3.1.4-1_amd64.deb ... Step #1: Unpacking libmpfr-dev:amd64 (3.1.4-1) ... Step #1: Selecting previously unselected package ninja-build. Step #1: Preparing to unpack .../ninja-build_1.5.1-0.1ubuntu1_amd64.deb ... Step #1: Unpacking ninja-build (1.5.1-0.1ubuntu1) ... Step #1: Selecting previously unselected package libmpc-dev:amd64. Step #1: Preparing to unpack .../libmpc-dev_1.0.3-1_amd64.deb ... Step #1: Unpacking libmpc-dev:amd64 (1.0.3-1) ... Step #1: Processing triggers for libc-bin (2.23-0ubuntu11.2) ... Step #1: Setting up cmake-data (3.5.1-1ubuntu3) ... Step #1: Setting up liblzo2-2:amd64 (2.08-1.2) ... Step #1: Setting up libarchive13:amd64 (3.1.2-11ubuntu0.16.04.8) ... Step #1: Setting up libcurl3:amd64 (7.47.0-1ubuntu2.18) ... Step #1: Setting up libjsoncpp1:amd64 (1.7.2-1) ... Step #1: Setting up cmake (3.5.1-1ubuntu3) ... Step #1: Setting up libgmpxx4ldbl:amd64 (2:6.1.0+dfsg-2) ... Step #1: Setting up libgmp-dev:amd64 (2:6.1.0+dfsg-2) ... Step #1: Setting up libmpfr-dev:amd64 (3.1.4-1) ... Step #1: Setting up ninja-build (1.5.1-0.1ubuntu1) ... Step #1: Setting up libmpc-dev:amd64 (1.0.3-1) ... Step #1: Processing triggers for libc-bin (2.23-0ubuntu11.2) ... Step #1: Removing intermediate container fc2330e13cce Step #1: ---> 25d690e490f2 Step #1: Step 3/5 : RUN git clone https://github.com/SerenityOS/serenity Step #1: ---> Running in 9ad2e3ba9f13 Step #1: Cloning into 'serenity'... Step #1: Removing intermediate container 9ad2e3ba9f13 Step #1: ---> ae6346f346b0 Step #1: Step 4/5 : COPY build.sh $SRC/ Step #1: ---> 74963cc99292 Step #1: Step 5/5 : WORKDIR $SRC/serenity/Meta/Lagom Step #1: ---> Running in 1d1b3ca44ee3 Step #1: Removing intermediate container 1d1b3ca44ee3 Step #1: ---> b56910bdd15e Step #1: Successfully built b56910bdd15e Step #1: Successfully tagged gcr.io/oss-fuzz/serenity:latest Finished Step #1 Starting Step #2 Step #2: Already have image: gcr.io/oss-fuzz/serenity Step #2: ++ tempfile Step #2: + SRCMAP=/tmp/fileoGbR04 Step #2: + echo '{}' Step #2: + PATHS_TO_SCAN=/src Step #2: + [[ c++ == \g\o ]] Step #2: ++ find /src -name .git -type d Step #2: + for DOT_GIT_DIR in '$(find $PATHS_TO_SCAN -name ".git" -type d)' Step #2: ++ dirname /src/serenity/.git Step #2: + GIT_DIR=/src/serenity Step #2: + cd /src/serenity Step #2: ++ git config --get remote.origin.url Step #2: + GIT_URL=https://github.com/SerenityOS/serenity Step #2: ++ git rev-parse HEAD Step #2: + GIT_REV=72fdab7bfb50505e23db0412be7c694c7b00eb66 Step #2: + jq_inplace /tmp/fileoGbR04 '."/src/serenity" = { type: "git", url: "https://github.com/SerenityOS/serenity", rev: "72fdab7bfb50505e23db0412be7c694c7b00eb66" }' Step #2: ++ tempfile Step #2: + F=/tmp/filePkIku3 Step #2: + cat /tmp/fileoGbR04 Step #2: + jq '."/src/serenity" = { type: "git", url: "https://github.com/SerenityOS/serenity", rev: "72fdab7bfb50505e23db0412be7c694c7b00eb66" }' Step #2: + mv /tmp/filePkIku3 /tmp/fileoGbR04 Step #2: + for DOT_GIT_DIR in '$(find $PATHS_TO_SCAN -name ".git" -type d)' Step #2: ++ dirname /src/aflplusplus/.git Step #2: + GIT_DIR=/src/aflplusplus Step #2: + cd /src/aflplusplus Step #2: ++ git config --get remote.origin.url Step #2: + GIT_URL=https://github.com/AFLplusplus/AFLplusplus.git Step #2: ++ git rev-parse HEAD Step #2: + GIT_REV=aeb7d7048371cd91ab9280c3958f1c35e5d5e758 Step #2: + jq_inplace /tmp/fileoGbR04 '."/src/aflplusplus" = { type: "git", url: "https://github.com/AFLplusplus/AFLplusplus.git", rev: "aeb7d7048371cd91ab9280c3958f1c35e5d5e758" }' Step #2: ++ tempfile Step #2: + F=/tmp/fileUbvoN7 Step #2: + cat /tmp/fileoGbR04 Step #2: + jq '."/src/aflplusplus" = { type: "git", url: "https://github.com/AFLplusplus/AFLplusplus.git", rev: "aeb7d7048371cd91ab9280c3958f1c35e5d5e758" }' Step #2: + mv /tmp/fileUbvoN7 /tmp/fileoGbR04 Step #2: ++ find /src -name .svn -type d Step #2: ++ find /src -name .hg -type d Step #2: + '[' '' '!=' '' ']' Step #2: + cat /tmp/fileoGbR04 Step #2: + rm /tmp/fileoGbR04 Step #2: { Step #2: "/src/serenity": { Step #2: "type": "git", Step #2: "url": "https://github.com/SerenityOS/serenity", Step #2: "rev": "72fdab7bfb50505e23db0412be7c694c7b00eb66" Step #2: }, Step #2: "/src/aflplusplus": { Step #2: "type": "git", Step #2: "url": "https://github.com/AFLplusplus/AFLplusplus.git", Step #2: "rev": "aeb7d7048371cd91ab9280c3958f1c35e5d5e758" Step #2: } Step #2: } Finished Step #2 Starting Step #3 Step #3: Pulling image: gcr.io/oss-fuzz-base/msan-libs-builder Step #3: Using default tag: latest Step #3: latest: Pulling from oss-fuzz-base/msan-libs-builder Step #3: 4007a89234b4: Already exists Step #3: 5dfa26c6b9c9: Already exists Step #3: 0ba7bf18aa40: Already exists Step #3: 4c6ec688ebe3: Already exists Step #3: aec4b0e74fec: Pulling fs layer Step #3: 666c66fe15d7: Pulling fs layer Step #3: 1c446f8ee06c: Pulling fs layer Step #3: bb46bfedc9e7: Pulling fs layer Step #3: 057ea9073f33: Pulling fs layer Step #3: 29ff25a8b8b4: Pulling fs layer Step #3: be6a7a44a58d: Pulling fs layer Step #3: 8d0105f02069: Pulling fs layer Step #3: be9b8b201caf: Pulling fs layer Step #3: 95affd4d888d: Pulling fs layer Step #3: 9b2a2e0c5c73: Pulling fs layer Step #3: a6ba970a9c32: Pulling fs layer Step #3: 2f9b1d9496fe: Pulling fs layer Step #3: 9b2a2e0c5c73: Waiting Step #3: 95affd4d888d: Waiting Step #3: a6ba970a9c32: Waiting Step #3: 29ff25a8b8b4: Waiting Step #3: 2f9b1d9496fe: Waiting Step #3: be6a7a44a58d: Waiting Step #3: 8d0105f02069: Waiting Step #3: be9b8b201caf: Waiting Step #3: bb46bfedc9e7: Waiting Step #3: 057ea9073f33: Waiting Step #3: 666c66fe15d7: Verifying Checksum Step #3: 666c66fe15d7: Download complete Step #3: bb46bfedc9e7: Verifying Checksum Step #3: bb46bfedc9e7: Download complete Step #3: aec4b0e74fec: Verifying Checksum Step #3: aec4b0e74fec: Download complete Step #3: 1c446f8ee06c: Verifying Checksum Step #3: 1c446f8ee06c: Download complete Step #3: 29ff25a8b8b4: Verifying Checksum Step #3: 29ff25a8b8b4: Download complete Step #3: be6a7a44a58d: Verifying Checksum Step #3: be6a7a44a58d: Download complete Step #3: be9b8b201caf: Download complete Step #3: 95affd4d888d: Verifying Checksum Step #3: 95affd4d888d: Download complete Step #3: 9b2a2e0c5c73: Verifying Checksum Step #3: 9b2a2e0c5c73: Download complete Step #3: a6ba970a9c32: Download complete Step #3: 8d0105f02069: Verifying Checksum Step #3: 8d0105f02069: Download complete Step #3: aec4b0e74fec: Pull complete Step #3: 666c66fe15d7: Pull complete Step #3: 1c446f8ee06c: Pull complete Step #3: bb46bfedc9e7: Pull complete Step #3: 2f9b1d9496fe: Verifying Checksum Step #3: 2f9b1d9496fe: Download complete Step #3: 057ea9073f33: Verifying Checksum Step #3: 057ea9073f33: Download complete Step #3: 057ea9073f33: Pull complete Step #3: 29ff25a8b8b4: Pull complete Step #3: be6a7a44a58d: Pull complete Step #3: 8d0105f02069: Pull complete Step #3: be9b8b201caf: Pull complete Step #3: 95affd4d888d: Pull complete Step #3: 9b2a2e0c5c73: Pull complete Step #3: a6ba970a9c32: Pull complete Step #3: 2f9b1d9496fe: Pull complete Step #3: Digest: sha256:b8463badb4c024964a18b592742b7b40c60ee069f78eddd3a6f2e38fa5fd2403 Step #3: Status: Downloaded newer image for gcr.io/oss-fuzz-base/msan-libs-builder:latest Step #3: gcr.io/oss-fuzz-base/msan-libs-builder:latest Finished Step #3 Starting Step #4 Step #4: Already have image: gcr.io/oss-fuzz/serenity Step #4: --------------------------------------------------------------- Step #4: ar: creating /usr/lib/libFuzzingEngine.a Step #4: Compiling libFuzzer to /usr/lib/libFuzzingEngine.a... done. Step #4: --------------------------------------------------------------- Step #4: CC=clang Step #4: CXX=clang++ Step #4: CFLAGS=-O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link Step #4: CXXFLAGS=-O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ Step #4: --------------------------------------------------------------- Step #4: + mkdir -p build Step #4: + cd build Step #4: + cmake -GNinja -DBUILD_LAGOM=ON -DENABLE_OSS_FUZZ=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ '-DCMAKE_CXX_FLAGS=-O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON' -DLINKER_FLAGS=-fsanitize=fuzzer .. Step #4: -- The C compiler identification is Clang 12.0.0 Step #4: -- The CXX compiler identification is Clang 12.0.0 Step #4: -- Detecting C compiler ABI info Step #4: -- Detecting C compiler ABI info - done Step #4: -- Check for working C compiler: /usr/local/bin/clang - skipped Step #4: -- Detecting C compile features Step #4: -- Detecting C compile features - done Step #4: -- Detecting CXX compiler ABI info Step #4: -- Detecting CXX compiler ABI info - done Step #4: -- Check for working CXX compiler: /usr/local/bin/clang++ - skipped Step #4: -- Detecting CXX compile features Step #4: -- Detecting CXX compile features - done Step #4: -- Configuring done Step #4: -- Generating done Step #4: CMake Warning (dev): Step #4: The detected version of Ninja: Step #4: Step #4: 1.5.1 Step #4: Step #4: is less than the version of Ninja required by CMake for adding restat Step #4: dependencies to the build.ninja manifest regeneration target: Step #4: Step #4: 1.8 Step #4: Step #4: Any pre-check scripts, such as those generated for file(GLOB Step #4: CONFIGURE_DEPENDS), will not be run by Ninja. Step #4: This warning is for project developers. Use -Wno-dev to suppress it. Step #4: Step #4: -- Build files have been written to: /src/serenity/Meta/Lagom/build Step #4: + ninja Step #4: [1/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp.o Step #4: [2/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp.o Step #4: [3/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp.o Step #4: [4/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Image.cpp.o Step #4: [5/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/XtermSuggestionDisplay.cpp.o Step #4: [6/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Validation.cpp.o Step #4: [7/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibIPC/Decoder.cpp.o Step #4: [8/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibIPC/Encoder.cpp.o Step #4: [9/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibIPC/Endpoint.cpp.o Step #4: [10/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibIPC/Message.cpp.o Step #4: [11/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/Editor.cpp.o Step #4: [12/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/InternalFunctions.cpp.o Step #4: [13/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/KeyCallbackMachine.cpp.o Step #4: [14/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/SuggestionManager.cpp.o Step #4: [15/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/AST.cpp.o Step #4: [16/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Console.cpp.o Step #4: [17/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Interpreter.cpp.o Step #4: [18/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Lexer.cpp.o Step #4: [19/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp.o Step #4: [20/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Parser.cpp.o Step #4: [21/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp.o Step #4: [22/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Token.cpp.o Step #4: [23/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/ArrayBufferConstructor.cpp.o Step #4: [24/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/Allocator.cpp.o Step #4: [25/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/Handle.cpp.o Step #4: [26/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp.o Step #4: [27/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/HeapBlock.cpp.o Step #4: [28/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/Array.cpp.o Step #4: [29/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/ArrayBuffer.cpp.o Step #4: [30/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/ArrayBufferPrototype.cpp.o Step #4: [31/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/ArrayConstructor.cpp.o Step #4: [32/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/NativeFunction.cpp.o Step #4: [33/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/ArrayIteratorPrototype.cpp.o Step #4: [34/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/ArrayIterator.cpp.o Step #4: [35/284] Building CXX object CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/BigIntConstructor.cpp.o Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Image.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Image.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Image.cpp.o -c /src/serenity/Userland/Libraries/LibELF/Image.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibELF/Image.cpp:28: Step #4: In file included from ../../../AK/Demangle.h:29: Step #4: In file included from ../../../AK/String.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<42>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<42>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<42, {{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 42}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 42, fmt = {{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 42}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 42}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Image.cpp:163:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 42}, enabled = (no value), Parameters = <>] Step #4: dbgln("ELF::Image::parse(): ELF Header not valid"); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<51>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<51>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<51, {{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 51}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 51, fmt = {{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 51}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 51}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Image.cpp:169:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{69, 76, 70, 58, 58, 73, 109, 97, 103, 101, ...}, 51}, enabled = (no value), Parameters = <>] Step #4: dbgln("ELF::Image::parse(): ELF Program Headers not valid"); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<66>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<66>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<66, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 66}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 66, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 66}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 66}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Image.cpp:207:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 66}, enabled = (no value), Parameters = <>] Step #4: dbgln("SHENANIGANS! Image::table_string() computed offset outside image."); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 3 errors generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp.o -c /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:29: Step #4: In file included from ../../../AK/String.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<51>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<51>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<51, {{68, 121, 110, 97, 109, 105, 99, 32, 115, 101, ...}, 51}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 51, fmt = {{68, 121, 110, 97, 109, 105, 99, 32, 115, 101, ...}, 51}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{68, 121, 110, 97, 109, 105, 99, 32, 115, 101, ...}, 51}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:76:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{68, 121, 110, 97, 109, 105, 99, 32, 115, 101, ...}, 51}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Dynamic section at address {} contains {} entries:", m_dynamic_address.as_ptr(), num_dynamic_sections); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<3>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<3>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<3, {{123, 125, 0}, 3}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 3, fmt = {{123, 125, 0}, 3}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{123, 125, 0}, 3}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:77:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{123, 125, 0}, 3}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "{}", builder.string_view()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<62>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<62>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<62, {{68, 121, 110, 97, 109, 105, 99, 79, 98, 106, ...}, 62}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 62, fmt = {{68, 121, 110, 97, 109, 105, 99, 79, 98, 106, ...}, 62}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{68, 121, 110, 97, 109, 105, 99, 79, 98, 106, ...}, 62}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:171:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{68, 121, 110, 97, 109, 105, 99, 79, 98, 106, ...}, 62}, enabled = (no value), Parameters = ] Step #4: dbgln("DynamicObject: DYNAMIC tag handling not implemented for DT_{}", name_for_dtag(entry.tag())); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<55>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<55>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<55, {{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 55}, 3>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 55, fmt = {{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 55}, param_count = 3, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 55}, 3>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:306:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 55}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Returning SYSV dynamic symbol with index {} for {}: {}", i, symbol.name(), symbol.address().as_ptr()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<54>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<54>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<54, {{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 54}, 3>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 54, fmt = {{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 54}, param_count = 3, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 54}, 3>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:351:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{82, 101, 116, 117, 114, 110, 105, 110, 103, 32, ...}, 54}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Returning GNU dynamic symbol with index {} for {}: {}", current_sym, symbol.name(), symbol.address().as_ptr()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<24>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<24>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<24, {{100, 105, 100, 32, 110, 111, 116, 32, 102, 105, ...}, 24}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 24, fmt = {{100, 105, 100, 32, 110, 111, 116, 32, 102, 105, ...}, 24}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{100, 105, 100, 32, 110, 111, 116, 32, 102, 105, ...}, 24}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:491:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{100, 105, 100, 32, 110, 111, 116, 32, 102, 105, ...}, 24}, enabled = (no value), Parameters = ] Step #4: dbgln("did not find symbol: {}", sym.name()); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<70>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<70>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<70, {{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 70}, 3>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 70, fmt = {{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 70}, param_count = 3, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 70}, 3>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:497:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 70}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "DynamicLoader: Jump slot relocation: putting {} ({:p}) into PLT at {}", sym.name(), symbol_location, (void*)relocation_address); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<22>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<22>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<22, {{108, 111, 111, 107, 105, 110, 103, 32, 117, 112, ...}, 22}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 22, fmt = {{108, 111, 111, 107, 105, 110, 103, 32, 117, 112, ...}, 22}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{108, 111, 111, 107, 105, 110, 103, 32, 117, 112, ...}, 22}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:506:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{108, 111, 111, 107, 105, 110, 103, 32, 117, 112, ...}, 22}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "looking up symbol: {}", symbol.name()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<32>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<32>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<32, {{115, 121, 109, 98, 111, 108, 32, 105, 115, 32, ...}, 32}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 32, fmt = {{115, 121, 109, 98, 111, 108, 32, 105, 115, 32, ...}, 32}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{115, 121, 109, 98, 111, 108, 32, 105, 115, 32, ...}, 32}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicObject.cpp:511:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{115, 121, 109, 98, 111, 108, 32, 105, 115, 32, ...}, 32}, enabled = false, Parameters = <>] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "symbol is defined in its object"); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 9 errors generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Validation.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Validation.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/Validation.cpp.o -c /src/serenity/Userland/Libraries/LibELF/Validation.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibELF/Validation.cpp:30: Step #4: In file included from ../../../AK/String.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<25>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<25>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<25, {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 25}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 25, fmt = {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 25}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 25}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:40:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 25}, enabled = (no value), Parameters = <>] Step #4: dbgln("File is not an ELF file."); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<31>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<31>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<31, {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 31}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 31, fmt = {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 31}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 31}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:46:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 31}, enabled = (no value), Parameters = <>] Step #4: dbgln("File is not a 32 bit ELF file."); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<38>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<38>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<38, {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 38}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 38, fmt = {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 38}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 38}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:52:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 105, 115, 32, 110, 111, ...}, 38}, enabled = (no value), Parameters = <>] Step #4: dbgln("File is not a little endian ELF file."); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<55>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<55>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<55, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 55}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 55, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 55}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 55}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:58:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 55}, enabled = (no value), Parameters = ] Step #4: dbgln("File has unrecognized ELF version ({}), expected ({})!", elf_header.e_ident[EI_VERSION], EV_CURRENT); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<48>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<48>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<48, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 48}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 48, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 48}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 48}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:64:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 48}, enabled = (no value), Parameters = ] Step #4: dbgln("File has unknown OS ABI ({}), expected SYSV(0)!", elf_header.e_ident[EI_OSABI]); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<40>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<40>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<40, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 40}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 40, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 40}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 40}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:70:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 40}, enabled = (no value), Parameters = ] Step #4: dbgln("File has unknown SYSV ABI version ({})!", elf_header.e_ident[EI_ABIVERSION]); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<50>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<50>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<50, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 50}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 50, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 50}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 50}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:76:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 50}, enabled = (no value), Parameters = ] Step #4: dbgln("File has unknown machine ({}), expected i386 (3)!", elf_header.e_machine); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<83>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<83>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<83, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 83}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 83, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 83}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 83}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:82:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 117, ...}, 83}, enabled = (no value), Parameters = ] Step #4: dbgln("File has unloadable ELF type ({}), expected REL (1), EXEC (2), DYN (3) or CORE(4)!", elf_header.e_type); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<59>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<59>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<59, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 59}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 59, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 59}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 59}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:94:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 59}, enabled = (no value), Parameters = ] Step #4: dbgln("File has incorrect ELF header size..? ({}), expected ({})!", elf_header.e_ehsize, sizeof(Elf32_Ehdr)); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<95>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<95>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<95, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 95}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 95, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 95}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 95}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:100:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 95}, enabled = (no value), Parameters = ] Step #4: dbgln("SHENANIGANS! program header offset ({}) or section header offset ({}) overlap with ELF header!", Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<100>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<100>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<100, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 100}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 100, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 100}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 100}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:108:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 100}, enabled = (no value), Parameters = ] Step #4: dbgln("SHENANIGANS! program header offset ({}) or section header offset ({}) are past the end of the file!", Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<89>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<89>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<89, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 89}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 89, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 89}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 89}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:116:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 89}, enabled = (no value), Parameters = ] Step #4: dbgln("SHENANIGANS! File has no program headers, but it does have a program header offset ({})!", elf_header.e_phoff); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<109>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<109>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<109, {{70, 105, 108, 101, 32, 100, 111, 101, 115, 32, ...}, 109}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 109, fmt = {{70, 105, 108, 101, 32, 100, 111, 101, 115, 32, ...}, 109}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 100, 111, 101, 115, 32, ...}, 109}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:122:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 100, 111, 101, 115, 32, ...}, 109}, enabled = (no value), Parameters = ] Step #4: dbgln("File does not have program headers directly after the ELF header? program header offset ({}), expected ({}).", Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<61>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<61>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<61, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 61}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 61, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 61}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 61}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:130:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 61}, enabled = (no value), Parameters = ] Step #4: dbgln("File has incorrect ELF header flags...? ({}), expected ({}).", elf_header.e_flags, 0); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<63>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<63>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<63, {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 63}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 63, fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 63}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 63}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:136:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{70, 105, 108, 101, 32, 104, 97, 115, 32, 105, ...}, 63}, enabled = (no value), Parameters = ] Step #4: dbgln("File has incorrect program header size..? ({}), expected ({}).", elf_header.e_phentsize, sizeof(Elf32_Phdr)); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<74>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<74>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<74, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 74}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 74, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 74}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 74}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:160:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 74}, enabled = (no value), Parameters = ] Step #4: dbgln("SHENANIGANS! End of last program header ({}) is past the end of the file!", end_of_last_program_header.value()); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<105>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<105>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<105, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 105}, 3>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 105, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 105}, param_count = 3, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 105}, 3>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:166:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 105}, enabled = (no value), Parameters = ] Step #4: dbgln("SHENANIGANS! Section header table begins at file offset {}, which is within program headers [ {} - {} ]!", Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<107>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<107>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<107, {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 107}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 107, fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 107}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 107}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:192:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 72, 69, 78, 65, 78, 73, 71, 65, 78, ...}, 107}, enabled = (no value), Parameters = ] Step #4: dbgln("SHENANIGANS! Section header string table index ({}) is not a valid index given we have {} section headers!", elf_header.e_shstrndx, elf_header.e_shnum); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<106>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<106>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<106, {{85, 110, 97, 98, 108, 101, 32, 116, 111, 32, ...}, 106}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 106, fmt = {{85, 110, 97, 98, 108, 101, 32, 116, 111, 32, ...}, 106}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{85, 110, 97, 98, 108, 101, 32, 116, 111, 32, ...}, 106}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/Validation.cpp:216:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{85, 110, 97, 98, 108, 101, 32, 116, 111, 32, ...}, 106}, enabled = (no value), Parameters = ] Step #4: dbgln("Unable to parse program headers from buffer, buffer too small! Buffer size: {}, End of program headers {}", buffer_size, end_of_last_program_header.value()); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: fatal error: too many errors emitted, stopping now [-ferror-limit=] Step #4: 20 errors generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp.o -c /src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp:27: Step #4: In file included from ../../../AK/HashTable.h:30: Step #4: In file included from ../../../AK/LogStream.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<32>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<32>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<32, {{85, 110, 107, 110, 111, 119, 110, 32, 115, 116, ...}, 32}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 32, fmt = {{85, 110, 107, 110, 111, 119, 110, 32, 115, 116, ...}, 32}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{85, 110, 107, 110, 111, 119, 110, 32, 115, 116, ...}, 32}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/MarkupGenerator.cpp:218:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{85, 110, 107, 110, 111, 119, 110, 32, 115, 116, ...}, 32}, enabled = (no value), Parameters = ] Step #4: dbgln("Unknown style type for token {}", token.name()); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 1 error generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp.o -c /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:30: Step #4: In file included from ../../../AK/StringBuilder.h:29: Step #4: In file included from ../../../AK/ByteBuffer.h:29: Step #4: In file included from ../../../AK/NonnullRefPtr.h:31: Step #4: In file included from ../../../AK/LogStream.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<44>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<44>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<44, {{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 44}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 44, fmt = {{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 44}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 44}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:152:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{68, 121, 110, 97, 109, 105, 99, 76, 111, 97, ...}, 44}, enabled = (no value), Parameters = <>] Step #4: dbgln("DynamicLoader::map failed: image is invalid"); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<37>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<37>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<37, {{76, 111, 97, 100, 101, 114, 46, 115, 111, 58, ...}, 37}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 37, fmt = {{76, 111, 97, 100, 101, 114, 46, 115, 111, 58, ...}, 37}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{76, 111, 97, 100, 101, 114, 46, 115, 111, 58, ...}, 37}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:203:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{76, 111, 97, 100, 101, 114, 46, 115, 111, 58, ...}, 37}, enabled = (no value), Parameters = ] Step #4: dbgln("Loader.so: {} unresolved symbol '{}'", m_filename, relocation.symbol().name()); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<10>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<10>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<10, {{76, 111, 97, 100, 101, 100, 32, 123, 125, 0}, 10}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 10, fmt = {{76, 111, 97, 100, 101, 100, 32, 123, 125, 0}, 10}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{76, 111, 97, 100, 101, 100, 32, 123, 125, 0}, 10}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:233:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{76, 111, 97, 100, 101, 100, 32, 123, 125, 0}, 10}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Loaded {}", m_filename); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<32>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<32>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<32, {{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 32}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 32, fmt = {{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 32}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 32}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:362:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 32}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Relocation symbol: {}, type: {}", relocation.symbol().name(), relocation.type()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<34>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<34>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<34, {{100, 121, 110, 97, 109, 105, 99, 32, 111, 98, ...}, 34}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 34, fmt = {{100, 121, 110, 97, 109, 105, 99, 32, 111, 98, ...}, 34}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{100, 121, 110, 97, 109, 105, 99, 32, 111, 98, ...}, 34}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:369:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{100, 121, 110, 97, 109, 105, 99, 32, 111, 98, ...}, 34}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "dynamic object base address: {:p}", m_dynamic_object->base_address().as_ptr()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<27>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<27>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<27, {{114, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 27}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 27, fmt = {{114, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 27}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{114, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 27}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:370:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{114, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 27}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "relocation offset: {:#08x}", relocation.offset()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<16>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<16>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<16, {{112, 97, 116, 99, 104, 95, 112, 116, 114, 58, ...}, 16}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 16, fmt = {{112, 97, 116, 99, 104, 95, 112, 116, 114, 58, ...}, 16}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{112, 97, 116, 99, 104, 95, 112, 116, 114, 58, ...}, 16}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:371:5: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{112, 97, 116, 99, 104, 95, 112, 116, 114, 58, ...}, 16}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "patch_ptr: {:p}", patch_ptr); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<40>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<40>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<40, {{78, 111, 110, 101, 32, 114, 101, 108, 111, 99, ...}, 40}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 40, fmt = {{78, 111, 110, 101, 32, 114, 101, 108, 111, 99, ...}, 40}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{78, 111, 110, 101, 32, 114, 101, 108, 111, 99, ...}, 40}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:376:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{78, 111, 110, 101, 32, 114, 101, 108, 111, 99, ...}, 40}, enabled = false, Parameters = <>] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "None relocation. No symbol, no nothing."); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<43>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<43>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<43, {{65, 98, 115, 111, 108, 117, 116, 101, 32, 114, ...}, 43}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 43, fmt = {{65, 98, 115, 111, 108, 117, 116, 101, 32, 114, ...}, 43}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{65, 98, 115, 111, 108, 117, 116, 101, 32, 114, ...}, 43}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:380:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{65, 98, 115, 111, 108, 117, 116, 101, 32, 114, ...}, 43}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Absolute relocation: name: '{}', value: {}", symbol.name(), symbol.value()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<29>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<29>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<29, {{69, 82, 82, 79, 82, 58, 32, 115, 121, 109, ...}, 29}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 29, fmt = {{69, 82, 82, 79, 82, 58, 32, 115, 121, 109, ...}, 29}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{69, 82, 82, 79, 82, 58, 32, 115, 121, 109, ...}, 29}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:385:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{69, 82, 82, 79, 82, 58, 32, 115, 121, 109, ...}, 29}, enabled = (no value), Parameters = ] Step #4: dbgln("ERROR: symbol not found: {}.", symbol.name()); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<24>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<24>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<24, {{32, 32, 32, 83, 121, 109, 98, 111, 108, 32, ...}, 24}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 24, fmt = {{32, 32, 32, 83, 121, 109, 98, 111, 108, 32, ...}, 24}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{32, 32, 32, 83, 121, 109, 98, 111, 108, 32, ...}, 24}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:390:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{32, 32, 32, 83, 121, 109, 98, 111, 108, 32, ...}, 24}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, " Symbol address: {:p}", *patch_ptr); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<42>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<42>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<42, {{80, 67, 45, 114, 101, 108, 97, 116, 105, 118, ...}, 42}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 42, fmt = {{80, 67, 45, 114, 101, 108, 97, 116, 105, 118, ...}, 42}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{80, 67, 45, 114, 101, 108, 97, 116, 105, 118, ...}, 42}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:395:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{80, 67, 45, 114, 101, 108, 97, 116, 105, 118, ...}, 42}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "PC-relative relocation: '{}', value: {:p}", symbol.name(), symbol.value()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<11>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<11>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<11, {{111, 98, 106, 101, 99, 116, 58, 32, 123, 125, ...}, 11}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 11, fmt = {{111, 98, 106, 101, 99, 116, 58, 32, 123, 125, ...}, 11}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{111, 98, 106, 101, 99, 116, 58, 32, 123, 125, ...}, 11}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:423:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{111, 98, 106, 101, 99, 116, 58, 32, 123, 125, ...}, 11}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "object: {}", m_filename); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<78>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<78>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<78, {{32, 32, 32, 32, 112, 97, 116, 99, 104, 32, ...}, 78}, 3>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 78, fmt = {{32, 32, 32, 32, 112, 97, 116, 99, 104, 32, ...}, 78}, param_count = 3, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{32, 32, 32, 32, 112, 97, 116, 99, 104, 32, ...}, 78}, 3>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:436:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{32, 32, 32, 32, 112, 97, 116, 99, 104, 32, ...}, 78}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, " patch ptr == {:p}, adding load base address ({:p}) to it and storing {:p}", *patch_ptr, m_dynamic_object->base_address().as_ptr(), *patch_ptr + m_dynamic_object->base_address().as_ptr()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<51>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<51>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<51, {{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 51}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 51, fmt = {{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 51}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 51}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:442:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{82, 101, 108, 111, 99, 97, 116, 105, 111, 110, ...}, 51}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Relocation type: R_386_TLS_TPOFF at offset {:#08x}", relocation.offset()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<17>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<17>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<17, {{83, 121, 109, 98, 111, 108, 32, 105, 110, 100, ...}, 17}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 17, fmt = {{83, 121, 109, 98, 111, 108, 32, 105, 110, 100, ...}, 17}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 121, 109, 98, 111, 108, 32, 105, 110, 100, ...}, 17}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:447:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 121, 109, 98, 111, 108, 32, 105, 110, 100, ...}, 17}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Symbol index: {}", symbol.index()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<25>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<25>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<25, {{83, 121, 109, 98, 111, 108, 32, 105, 115, 95, ...}, 25}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 25, fmt = {{83, 121, 109, 98, 111, 108, 32, 105, 115, 95, ...}, 25}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{83, 121, 109, 98, 111, 108, 32, 105, 115, 95, ...}, 25}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:448:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{83, 121, 109, 98, 111, 108, 32, 105, 115, 95, ...}, 25}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "Symbol is_undefined?: {}", symbol.is_undefined()); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<39>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<39>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<39, {{116, 108, 115, 32, 101, 110, 100, 32, 111, 102, ...}, 39}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 39, fmt = {{116, 108, 115, 32, 101, 110, 100, 32, 111, 102, ...}, 39}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{116, 108, 115, 32, 101, 110, 100, 32, 111, 102, ...}, 39}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:459:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{116, 108, 115, 32, 101, 110, 100, 32, 111, 102, ...}, 39}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "tls end offset: {}, total tls size: {}", offset_of_tls_end, total_tls_size); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<15>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<15>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<15, {{42, 112, 97, 116, 99, 104, 32, 112, 116, 114, ...}, 15}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 15, fmt = {{42, 112, 97, 116, 99, 104, 32, 112, 116, 114, ...}, 15}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{42, 112, 97, 116, 99, 104, 32, 112, 116, 114, ...}, 15}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibELF/DynamicLoader.cpp:461:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{42, 112, 97, 116, 99, 104, 32, 112, 116, 114, ...}, 15}, enabled = false, Parameters = ] Step #4: dbgln_if(DYNAMIC_LOAD_DEBUG, "*patch ptr: {}", (i32)*patch_ptr); Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: fatal error: too many errors emitted, stopping now [-ferror-limit=] Step #4: 20 errors generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp.o -c /src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp:29: Step #4: In file included from ../../../AK/HashTable.h:30: Step #4: In file included from ../../../AK/LogStream.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<26>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<26>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<26, {{71, 97, 114, 98, 97, 103, 101, 32, 99, 111, ...}, 26}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 26, fmt = {{71, 97, 114, 98, 97, 103, 101, 32, 99, 111, ...}, 26}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{71, 97, 114, 98, 97, 103, 101, 32, 99, 111, ...}, 26}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp:278:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{71, 97, 114, 98, 97, 103, 101, 32, 99, 111, ...}, 26}, enabled = (no value), Parameters = <>] Step #4: dbgln("Garbage collection report"); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<46>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<46>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<46, {{61, 61, 61, 61, 61, 61, 61, 61, 61, 61, ...}, 46}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 46, fmt = {{61, 61, 61, 61, 61, 61, 61, 61, 61, 61, ...}, 46}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{61, 61, 61, 61, 61, 61, 61, 61, 61, 61, ...}, 46}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp:279:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{61, 61, 61, 61, 61, 61, 61, 61, 61, 61, ...}, 46}, enabled = (no value), Parameters = <>] Step #4: dbgln("============================================="); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<23>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<23>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<23, {{32, 32, 32, 32, 32, 84, 105, 109, 101, 32, ...}, 23}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 23, fmt = {{32, 32, 32, 32, 32, 84, 105, 109, 101, 32, ...}, 23}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{32, 32, 32, 32, 32, 84, 105, 109, 101, 32, ...}, 23}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp:280:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{32, 32, 32, 32, 32, 84, 105, 109, 101, 32, ...}, 23}, enabled = (no value), Parameters = ] Step #4: dbgln(" Time spent: {} ms", time_spent); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<31>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<31>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<31, {{32, 32, 32, 32, 32, 76, 105, 118, 101, 32, ...}, 31}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 31, fmt = {{32, 32, 32, 32, 32, 76, 105, 118, 101, 32, ...}, 31}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{32, 32, 32, 32, 32, 76, 105, 118, 101, 32, ...}, 31}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/Heap/Heap.cpp:281:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{32, 32, 32, 32, 32, 76, 105, 118, 101, 32, ...}, 31}, enabled = (no value), Parameters = ] Step #4: dbgln(" Live cells: {} ({} bytes)", live_cells, live_cell_bytes); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 4 errors generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp.o -c /src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp:28: Step #4: In file included from ../../../AK/FlyString.h:29: Step #4: In file included from ../../../AK/String.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<40>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<40>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<40, {{68, 121, 105, 110, 103, 32, 98, 101, 99, 97, ...}, 40}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 40, fmt = {{68, 121, 105, 110, 103, 32, 98, 101, 99, 97, ...}, 40}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{68, 121, 105, 110, 103, 32, 98, 101, 99, 97, ...}, 40}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/Runtime/Value.cpp:373:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{68, 121, 105, 110, 103, 32, 98, 101, 99, 97, ...}, 40}, enabled = (no value), Parameters = ] Step #4: dbgln("Dying because I can't to_object() on {}", *this); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 1 error generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp.o -c /src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp:28: Step #4: In file included from ../../../Userland/Libraries/LibGUI/TextEditor.h:29: Step #4: In file included from ../../../AK/Function.h:29: Step #4: In file included from ../../../AK/OwnPtr.h:29: Step #4: In file included from ../../../AK/NonnullOwnPtr.h:30: Step #4: In file included from ../../../AK/LogStream.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<26>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<26>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<26, {{123, 125, 123, 125, 32, 64, 32, 39, 123, 125, ...}, 26}, 7>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 26, fmt = {{123, 125, 123, 125, 32, 64, 32, 39, 123, 125, ...}, 26}, param_count = 7, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{123, 125, 123, 125, 32, 64, 32, 39, 123, 125, ...}, 26}, 7>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibJS/SyntaxHighlighter.cpp:110:9: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{123, 125, 123, 125, 32, 64, 32, 39, 123, 125, ...}, 26}, enabled = false, Parameters = ] Step #4: dbgln_if(SYNTAX_HIGHLIGHTING_DEBUG, "{}{} @ '{}' {}:{} - {}:{}", Step #4: ^ Step #4: ../../../AK/Format.h:657:38: note: expanded from macro 'dbgln_if' Step #4: # define dbgln_if(flag, fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 1 error generated. Step #4: FAILED: /usr/local/bin/clang++ -I../../.. -I../../../Userland -I../../../Userland/Libraries -I. -O1 -fno-omit-frame-pointer -gline-tables-only -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=fuzzer-no-link -stdlib=libc++ -DOSS_FUZZ=ON -std=c++2a -fPIC -g -Wno-deprecated-copy -Wno-overloaded-virtual -MD -MT CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/Editor.cpp.o -MF CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/Editor.cpp.o.d -o CMakeFiles/Lagom.dir/src/serenity/Userland/Libraries/LibLine/Editor.cpp.o -c /src/serenity/Userland/Libraries/LibLine/Editor.cpp Step #4: In file included from /src/serenity/Userland/Libraries/LibLine/Editor.cpp:28: Step #4: In file included from /src/serenity/Userland/Libraries/LibLine/Editor.h:31: Step #4: In file included from ../../../AK/ByteBuffer.h:29: Step #4: In file included from ../../../AK/NonnullRefPtr.h:31: Step #4: In file included from ../../../AK/LogStream.h:29: Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<40>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<40>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<40, {{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 40}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 40, fmt = {{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 40}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 40}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibLine/Editor.cpp:368:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 40}, enabled = (no value), Parameters = ] Step #4: dbgln("LibLine: Unknown internal function '{}'", binding.binding); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<36>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<36>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<36, {{76, 105, 98, 76, 105, 110, 101, 58, 32, 73, ...}, 36}, 2>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 36, fmt = {{76, 105, 98, 76, 105, 110, 101, 58, 32, 73, ...}, 36}, param_count = 2, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{76, 105, 98, 76, 105, 110, 101, 58, 32, 73, ...}, 36}, 2>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibLine/Editor.cpp:807:17: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{76, 105, 98, 76, 105, 110, 101, 58, 32, 73, ...}, 36}, enabled = (no value), Parameters = ] Step #4: dbgln("LibLine: Invalid CSI: {:02x} ({:c})", code_point, code_point); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<27>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<27>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<27, {{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 27}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 27, fmt = {{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 27}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 27}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibLine/Editor.cpp:868:17: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{76, 105, 98, 76, 105, 110, 101, 58, 32, 85, ...}, 27}, enabled = (no value), Parameters = ] Step #4: dbgln("LibLine: Unhandled '~': {}", param1); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<28>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<28>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<28, {{69, 114, 114, 111, 114, 32, 119, 104, 105, 108, ...}, 28}, 1>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 28, fmt = {{69, 114, 114, 111, 114, 32, 119, 104, 105, 108, ...}, 28}, param_count = 1, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{69, 114, 114, 111, 114, 32, 119, 104, 105, 108, ...}, 28}, 1>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibLine/Editor.cpp:1648:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{69, 114, 114, 111, 114, 32, 119, 104, 105, 108, ...}, 28}, enabled = (no value), Parameters = ] Step #4: dbgln("Error while reading DSR: {}", strerror(errno)); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: ../../../AK/Format.h:126:44: error: call to consteval function '(anonymous namespace)::extract_used_argument_index<41>' is not a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:143:75: note: in instantiation of function template specialization '(anonymous namespace)::count_fmt_params<41>' requested here Step #4: template fmt, size_t param_count, auto check = count_fmt_params(fmt.data)> Step #4: ^ Step #4: ../../../AK/Format.h:144:16: note: in instantiation of default argument for 'check_format_parameter_consistency<41, {{84, 101, 114, 109, 105, 110, 97, 108, 32, 68, ...}, 41}, 0>' required here Step #4: constexpr bool check_format_parameter_consistency() Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:191:38: note: while substituting deduced template arguments into function template 'check_format_parameter_consistency' [with N = 41, fmt = {{84, 101, 114, 109, 105, 110, 97, 108, 32, 68, ...}, 41}, param_count = 0, check = (no value)] Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^ Step #4: ../../../AK/Format.h:191:38: note: while substituting template arguments into constraint expression here Step #4: concept ConsistentFormatParameters = check_format_parameter_consistency(); Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: ../../../AK/Format.h:553:54: note: while checking the satisfaction of concept 'ConsistentFormatParameters<{{84, 101, 114, 109, 105, 110, 97, 108, 32, 68, ...}, 41}, 0>' requested here Step #4: void dbgln(const Parameters&... parameters) requires ConsistentFormatParameters Step #4: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step #4: /src/serenity/Userland/Libraries/LibLine/Editor.cpp:1656:13: note: while substituting deduced template arguments into function template 'dbgln' [with fmt = {{84, 101, 114, 109, 105, 110, 97, 108, 32, 68, ...}, 41}, enabled = (no value), Parameters = <>] Step #4: dbgln("Terminal DSR issue; received no response"); Step #4: ^ Step #4: ../../../AK/Format.h:656:29: note: expanded from macro 'dbgln' Step #4: # define dbgln(fmt, ...) dbgln(__VA_ARGS__) Step #4: ^ Step #4: ../../../AK/Format.h:126:75: note: function parameter 'fmt' with unknown value cannot be used in a constant expression Step #4: auto used_argument_index = extract_used_argument_index(fmt, specifier_start_index, i, result.next_implicit_argument_index); Step #4: ^ Step #4: ../../../AK/Format.h:75:46: note: declared here Step #4: consteval auto count_fmt_params(const char (&fmt)[N]) Step #4: ^ Step #4: 5 errors generated. Step #4: ninja: build stopped: subcommand failed. Step #4: ******************************************************************************** Step #4: Failed to build. Step #4: To reproduce, run: Step #4: python infra/helper.py build_image serenity Step #4: python infra/helper.py build_fuzzers --sanitizer address --engine libfuzzer --architecture x86_64 serenity Step #4: ******************************************************************************** Finished Step #4 ERROR ERROR: build step 4 "gcr.io/oss-fuzz/serenity" failed: step exited with non-zero status: 1