lib/zstd/compress/zstd_opt.c:1170 ZSTD_compressBlock_opt_generic() warn: inconsistent indenting

From: kernel test robot
Date: Thu Nov 25 2021 - 09:57:46 EST

tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head: 5f53fa508db098c9d372423a6dac31c8a5679cdf
commit: e0c1b49f5b674cca7b10549c53b3791d0bbc90a8 lib: zstd: Upgrade to latest upstream zstd version 1.4.10
date: 2 weeks ago
config: x86_64-randconfig-m001-20211116 (https://download.01.org/0day-ci/archive/20211125/202111252259.qU4k14YN-lkp@xxxxxxxxx/config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@xxxxxxxxx>

New smatch warnings:
lib/zstd/compress/zstd_opt.c:1170 ZSTD_compressBlock_opt_generic() warn: inconsistent indenting
lib/zstd/compress/zstd_compress.c:3602 ZSTD_initCDict_internal() warn: inconsistent indenting
lib/zstd/decompress/huf_decompress.c:397 HUF_decompress4X1_usingDTable_internal_body() warn: maybe use && instead of &
lib/zstd/decompress/huf_decompress.c:397 HUF_decompress4X1_usingDTable_internal_body() warn: maybe use && instead of &
lib/zstd/decompress/huf_decompress.c:850 HUF_decompress4X2_usingDTable_internal_body() warn: maybe use && instead of &
lib/zstd/decompress/huf_decompress.c:850 HUF_decompress4X2_usingDTable_internal_body() warn: maybe use && instead of &
lib/zstd/compress/zstd_lazy.c:983 ZSTD_compressBlock_lazy_generic() warn: if statement not indented
lib/zstd/compress/zstd_lazy.c:1254 ZSTD_compressBlock_lazy_extDict_generic() warn: if statement not indented

Old smatch warnings:
lib/zstd/compress/zstd_lazy.c:1275 ZSTD_compressBlock_lazy_extDict_generic() warn: if statement not indented
lib/zstd/compress/zstd_lazy.c:1285 ZSTD_compressBlock_lazy_extDict_generic() warn: if statement not indented
lib/zstd/compress/zstd_lazy.c:1316 ZSTD_compressBlock_lazy_extDict_generic() warn: if statement not indented
lib/zstd/compress/zstd_lazy.c:1362 ZSTD_compressBlock_lazy_extDict_generic() warn: if statement not indented

vim +1170 lib/zstd/compress/zstd_opt.c

929
930 FORCE_INLINE_TEMPLATE size_t
931 ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
932 seqStore_t* seqStore,
933 U32 rep[ZSTD_REP_NUM],
934 const void* src, size_t srcSize,
935 const int optLevel,
936 const ZSTD_dictMode_e dictMode)
937 {
938 optState_t* const optStatePtr = &ms->opt;
939 const BYTE* const istart = (const BYTE*)src;
940 const BYTE* ip = istart;
941 const BYTE* anchor = istart;
942 const BYTE* const iend = istart + srcSize;
943 const BYTE* const ilimit = iend - 8;
944 const BYTE* const base = ms->window.base;
945 const BYTE* const prefixStart = base + ms->window.dictLimit;
946 const ZSTD_compressionParameters* const cParams = &ms->cParams;
947
948 U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
949 U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;
950 U32 nextToUpdate3 = ms->nextToUpdate;
951
952 ZSTD_optimal_t* const opt = optStatePtr->priceTable;
953 ZSTD_match_t* const matches = optStatePtr->matchTable;
954 ZSTD_optimal_t lastSequence;
955 ZSTD_optLdm_t optLdm;
956
957 optLdm.seqStore = ms->ldmSeqStore ? *ms->ldmSeqStore : kNullRawSeqStore;
958 optLdm.endPosInBlock = optLdm.startPosInBlock = optLdm.offset = 0;
959 ZSTD_opt_getNextMatchAndUpdateSeqStore(&optLdm, (U32)(ip-istart), (U32)(iend-ip));
960
961 /* init */
962 DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u",
963 (U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);
964 assert(optLevel <= 2);
965 ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);
966 ip += (ip==prefixStart);
967
968 /* Match Loop */
969 while (ip < ilimit) {
970 U32 cur, last_pos = 0;
971
972 /* find first match */
973 { U32 const litlen = (U32)(ip - anchor);
974 U32 const ll0 = !litlen;
975 U32 nbMatches = ZSTD_BtGetAllMatches(matches, ms, &nextToUpdate3, ip, iend, dictMode, rep, ll0, minMatch);
976 ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,
977 (U32)(ip-istart), (U32)(iend - ip));
978 if (!nbMatches) { ip++; continue; }
979
980 /* initialize opt[0] */
981 { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
982 opt[0].mlen = 0; /* means is_a_literal */
983 opt[0].litlen = litlen;
984 /* We don't need to include the actual price of the literals because
985 * it is static for the duration of the forward pass, and is included
986 * in every price. We include the literal length to avoid negative
987 * prices when we subtract the previous literal length.
988 */
989 opt[0].price = ZSTD_litLengthPrice(litlen, optStatePtr, optLevel);
990
991 /* large match -> immediate encoding */
992 { U32 const maxML = matches[nbMatches-1].len;
993 U32 const maxOffset = matches[nbMatches-1].off;
994 DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffCode=%u at cPos=%u => start new series",
995 nbMatches, maxML, maxOffset, (U32)(ip-prefixStart));
996
997 if (maxML > sufficient_len) {
998 lastSequence.litlen = litlen;
999 lastSequence.mlen = maxML;
1000 lastSequence.off = maxOffset;
1001 DEBUGLOG(6, "large match (%u>%u), immediate encoding",
1002 maxML, sufficient_len);
1003 cur = 0;
1004 last_pos = ZSTD_totalLen(lastSequence);
1005 goto _shortestPath;
1006 } }
1007
1008 /* set prices for first matches starting position == 0 */
1009 { U32 const literalsPrice = opt[0].price + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
1010 U32 pos;
1011 U32 matchNb;
1012 for (pos = 1; pos < minMatch; pos++) {
1013 opt[pos].price = ZSTD_MAX_PRICE; /* mlen, litlen and price will be fixed during forward scanning */
1014 }
1015 for (matchNb = 0; matchNb < nbMatches; matchNb++) {
1016 U32 const offset = matches[matchNb].off;
1017 U32 const end = matches[matchNb].len;
1018 for ( ; pos <= end ; pos++ ) {
1019 U32 const matchPrice = ZSTD_getMatchPrice(offset, pos, optStatePtr, optLevel);
1020 U32 const sequencePrice = literalsPrice + matchPrice;
1021 DEBUGLOG(7, "rPos:%u => set initial price : %.2f",
1022 pos, ZSTD_fCost(sequencePrice));
1023 opt[pos].mlen = pos;
1024 opt[pos].off = offset;
1025 opt[pos].litlen = litlen;
1026 opt[pos].price = sequencePrice;
1027 } }
1028 last_pos = pos-1;
1029 }
1030 }
1031
1032 /* check further positions */
1033 for (cur = 1; cur <= last_pos; cur++) {
1034 const BYTE* const inr = ip + cur;
1035 assert(cur < ZSTD_OPT_NUM);
1036 DEBUGLOG(7, "cPos:%zi==rPos:%u", inr-istart, cur)
1037
1038 /* Fix current position with one literal if cheaper */
1039 { U32 const litlen = (opt[cur-1].mlen == 0) ? opt[cur-1].litlen + 1 : 1;
1040 int const price = opt[cur-1].price
1041 + ZSTD_rawLiteralsCost(ip+cur-1, 1, optStatePtr, optLevel)
1042 + ZSTD_litLengthPrice(litlen, optStatePtr, optLevel)
1043 - ZSTD_litLengthPrice(litlen-1, optStatePtr, optLevel);
1044 assert(price < 1000000000); /* overflow check */
1045 if (price <= opt[cur].price) {
1046 DEBUGLOG(7, "cPos:%zi==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)",
1047 inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen,
1048 opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
1049 opt[cur].mlen = 0;
1050 opt[cur].off = 0;
1051 opt[cur].litlen = litlen;
1052 opt[cur].price = price;
1053 } else {
1054 DEBUGLOG(7, "cPos:%zi==rPos:%u : literal would cost more (%.2f>%.2f) (hist:%u,%u,%u)",
1055 inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price),
1056 opt[cur].rep[0], opt[cur].rep[1], opt[cur].rep[2]);
1057 }
1058 }
1059
1060 /* Set the repcodes of the current position. We must do it here
1061 * because we rely on the repcodes of the 2nd to last sequence being
1062 * correct to set the next chunks repcodes during the backward
1063 * traversal.
1064 */
1065 ZSTD_STATIC_ASSERT(sizeof(opt[cur].rep) == sizeof(repcodes_t));
1066 assert(cur >= opt[cur].mlen);
1067 if (opt[cur].mlen != 0) {
1068 U32 const prev = cur - opt[cur].mlen;
1069 repcodes_t newReps = ZSTD_updateRep(opt[prev].rep, opt[cur].off, opt[cur].litlen==0);
1070 ZSTD_memcpy(opt[cur].rep, &newReps, sizeof(repcodes_t));
1071 } else {
1072 ZSTD_memcpy(opt[cur].rep, opt[cur - 1].rep, sizeof(repcodes_t));
1073 }
1074
1075 /* last match must start at a minimum distance of 8 from oend */
1076 if (inr > ilimit) continue;
1077
1078 if (cur == last_pos) break;
1079
1080 if ( (optLevel==0) /*static_test*/
1081 && (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) {
1082 DEBUGLOG(7, "move to next rPos:%u : price is <=", cur+1);
1083 continue; /* skip unpromising positions; about ~+6% speed, -0.01 ratio */
1084 }
1085
1086 { U32 const ll0 = (opt[cur].mlen != 0);
1087 U32 const litlen = (opt[cur].mlen == 0) ? opt[cur].litlen : 0;
1088 U32 const previousPrice = opt[cur].price;
1089 U32 const basePrice = previousPrice + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
1090 U32 nbMatches = ZSTD_BtGetAllMatches(matches, ms, &nextToUpdate3, inr, iend, dictMode, opt[cur].rep, ll0, minMatch);
1091 U32 matchNb;
1092
1093 ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,
1094 (U32)(inr-istart), (U32)(iend-inr));
1095
1096 if (!nbMatches) {
1097 DEBUGLOG(7, "rPos:%u : no match found", cur);
1098 continue;
1099 }
1100
1101 { U32 const maxML = matches[nbMatches-1].len;
1102 DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of maxLength=%u",
1103 inr-istart, cur, nbMatches, maxML);
1104
1105 if ( (maxML > sufficient_len)
1106 || (cur + maxML >= ZSTD_OPT_NUM) ) {
1107 lastSequence.mlen = maxML;
1108 lastSequence.off = matches[nbMatches-1].off;
1109 lastSequence.litlen = litlen;
1110 cur -= (opt[cur].mlen==0) ? opt[cur].litlen : 0; /* last sequence is actually only literals, fix cur to last match - note : may underflow, in which case, it's first sequence, and it's okay */
1111 last_pos = cur + ZSTD_totalLen(lastSequence);
1112 if (cur > ZSTD_OPT_NUM) cur = 0; /* underflow => first match */
1113 goto _shortestPath;
1114 } }
1115
1116 /* set prices using matches found at position == cur */
1117 for (matchNb = 0; matchNb < nbMatches; matchNb++) {
1118 U32 const offset = matches[matchNb].off;
1119 U32 const lastML = matches[matchNb].len;
1120 U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
1121 U32 mlen;
1122
1123 DEBUGLOG(7, "testing match %u => offCode=%4u, mlen=%2u, llen=%2u",
1124 matchNb, matches[matchNb].off, lastML, litlen);
1125
1126 for (mlen = lastML; mlen >= startML; mlen--) { /* scan downward */
1127 U32 const pos = cur + mlen;
1128 int const price = basePrice + ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);
1129
1130 if ((pos > last_pos) || (price < opt[pos].price)) {
1131 DEBUGLOG(7, "rPos:%u (ml=%2u) => new better price (%.2f<%.2f)",
1132 pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
1133 while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } /* fill empty positions */
1134 opt[pos].mlen = mlen;
1135 opt[pos].off = offset;
1136 opt[pos].litlen = litlen;
1137 opt[pos].price = price;
1138 } else {
1139 DEBUGLOG(7, "rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)",
1140 pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
1141 if (optLevel==0) break; /* early update abort; gets ~+10% speed for about -0.01 ratio loss */
1142 }
1143 } } }
1144 } /* for (cur = 1; cur <= last_pos; cur++) */
1145
1146 lastSequence = opt[last_pos];
1147 cur = last_pos > ZSTD_totalLen(lastSequence) ? last_pos - ZSTD_totalLen(lastSequence) : 0; /* single sequence, and it starts before `ip` */
1148 assert(cur < ZSTD_OPT_NUM); /* control overflow*/
1149
1150 _shortestPath: /* cur, last_pos, best_mlen, best_off have to be set */
1151 assert(opt[0].mlen == 0);
1152
1153 /* Set the next chunk's repcodes based on the repcodes of the beginning
1154 * of the last match, and the last sequence. This avoids us having to
1155 * update them while traversing the sequences.
1156 */
1157 if (lastSequence.mlen != 0) {
1158 repcodes_t reps = ZSTD_updateRep(opt[cur].rep, lastSequence.off, lastSequence.litlen==0);
1159 ZSTD_memcpy(rep, &reps, sizeof(reps));
1160 } else {
1161 ZSTD_memcpy(rep, opt[cur].rep, sizeof(repcodes_t));
1162 }
1163
1164 { U32 const storeEnd = cur + 1;
1165 U32 storeStart = storeEnd;
1166 U32 seqPos = cur;
1167
1168 DEBUGLOG(6, "start reverse traversal (last_pos:%u, cur:%u)",
1169 last_pos, cur); (void)last_pos;
> 1170 assert(storeEnd < ZSTD_OPT_NUM);
1171 DEBUGLOG(6, "last sequence copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
1172 storeEnd, lastSequence.litlen, lastSequence.mlen, lastSequence.off);
1173 opt[storeEnd] = lastSequence;
1174 while (seqPos > 0) {
1175 U32 const backDist = ZSTD_totalLen(opt[seqPos]);
1176 storeStart--;
1177 DEBUGLOG(6, "sequence from rPos=%u copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
1178 seqPos, storeStart, opt[seqPos].litlen, opt[seqPos].mlen, opt[seqPos].off);
1179 opt[storeStart] = opt[seqPos];
1180 seqPos = (seqPos > backDist) ? seqPos - backDist : 0;
1181 }
1182
1183 /* save sequences */
1184 DEBUGLOG(6, "sending selected sequences into seqStore")
1185 { U32 storePos;
1186 for (storePos=storeStart; storePos <= storeEnd; storePos++) {
1187 U32 const llen = opt[storePos].litlen;
1188 U32 const mlen = opt[storePos].mlen;
1189 U32 const offCode = opt[storePos].off;
1190 U32 const advance = llen + mlen;
1191 DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u",
1192 anchor - istart, (unsigned)llen, (unsigned)mlen);
1193
1194 if (mlen==0) { /* only literals => must be last "sequence", actually starting a new stream of sequences */
1195 assert(storePos == storeEnd); /* must be last sequence */
1196 ip = anchor + llen; /* last "sequence" is a bunch of literals => don't progress anchor */
1197 continue; /* will finish */
1198 }
1199
1200 assert(anchor + llen <= iend);
1201 ZSTD_updateStats(optStatePtr, llen, anchor, offCode, mlen);
1202 ZSTD_storeSeq(seqStore, llen, anchor, iend, offCode, mlen-MINMATCH);
1203 anchor += advance;
1204 ip = anchor;
1205 } }
1206 ZSTD_setBasePrices(optStatePtr, optLevel);
1207 }
1208 } /* while (ip < ilimit) */
1209
1210 /* Return the last literals size */
1211 return (size_t)(iend - anchor);
1212 }
1213

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@xxxxxxxxxxxx