Re: [PATCH] lib/zlib_inflate/inffast: Check config in C to avoid unused function warning

[kernel test robot <lkp@intel.com>]

[-- Attachment #1: Type: text/plain, Size: 15370 bytes --]

Hi Paul,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on linus/master]
[also build test ERROR on v5.15-rc1 next-20210916]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Paul-Menzel/lib-zlib_inflate-inffast-Check-config-in-C-to-avoid-unused-function-warning/20210916-222359
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git ff1ffd71d5f0612cf194f5705c671d6b64bf5f91
config: hexagon-randconfig-r045-20210916 (attached as .config)
compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project c8b3d7d6d6de37af68b2f379d0e37304f78e115f)
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/0day-ci/linux/commit/127eebd64d8e291cf75563499f6c886bd54a99d8
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Paul-Menzel/lib-zlib_inflate-inffast-Check-config-in-C-to-avoid-unused-function-warning/20210916-222359
        git checkout 127eebd64d8e291cf75563499f6c886bd54a99d8
        # save the attached .config to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=hexagon SHELL=/bin/bash lib/zlib_inflate/

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

All errors (new ones prefixed by >>):

>> lib/zlib_inflate/inffast.c:257:18: error: use of undeclared identifier 'CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS'
                               *sout++ = CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS ? *sfrom++ : get_unaligned16(sfrom++);
                                         ^
   1 error generated.


vim +/CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS +257 lib/zlib_inflate/inffast.c

    29	
    30	/*
    31	   Decode literal, length, and distance codes and write out the resulting
    32	   literal and match bytes until either not enough input or output is
    33	   available, an end-of-block is encountered, or a data error is encountered.
    34	   When large enough input and output buffers are supplied to inflate(), for
    35	   example, a 16K input buffer and a 64K output buffer, more than 95% of the
    36	   inflate execution time is spent in this routine.
    37	
    38	   Entry assumptions:
    39	
    40	        state->mode == LEN
    41	        strm->avail_in >= 6
    42	        strm->avail_out >= 258
    43	        start >= strm->avail_out
    44	        state->bits < 8
    45	
    46	   On return, state->mode is one of:
    47	
    48	        LEN -- ran out of enough output space or enough available input
    49	        TYPE -- reached end of block code, inflate() to interpret next block
    50	        BAD -- error in block data
    51	
    52	   Notes:
    53	
    54	    - The maximum input bits used by a length/distance pair is 15 bits for the
    55	      length code, 5 bits for the length extra, 15 bits for the distance code,
    56	      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
    57	      Therefore if strm->avail_in >= 6, then there is enough input to avoid
    58	      checking for available input while decoding.
    59	
    60	    - The maximum bytes that a single length/distance pair can output is 258
    61	      bytes, which is the maximum length that can be coded.  inflate_fast()
    62	      requires strm->avail_out >= 258 for each loop to avoid checking for
    63	      output space.
    64	
    65	    - @start:	inflate()'s starting value for strm->avail_out
    66	 */
    67	void inflate_fast(z_streamp strm, unsigned start)
    68	{
    69	    struct inflate_state *state;
    70	    const unsigned char *in;    /* local strm->next_in */
    71	    const unsigned char *last;  /* while in < last, enough input available */
    72	    unsigned char *out;         /* local strm->next_out */
    73	    unsigned char *beg;         /* inflate()'s initial strm->next_out */
    74	    unsigned char *end;         /* while out < end, enough space available */
    75	#ifdef INFLATE_STRICT
    76	    unsigned dmax;              /* maximum distance from zlib header */
    77	#endif
    78	    unsigned wsize;             /* window size or zero if not using window */
    79	    unsigned whave;             /* valid bytes in the window */
    80	    unsigned write;             /* window write index */
    81	    unsigned char *window;      /* allocated sliding window, if wsize != 0 */
    82	    unsigned long hold;         /* local strm->hold */
    83	    unsigned bits;              /* local strm->bits */
    84	    code const *lcode;          /* local strm->lencode */
    85	    code const *dcode;          /* local strm->distcode */
    86	    unsigned lmask;             /* mask for first level of length codes */
    87	    unsigned dmask;             /* mask for first level of distance codes */
    88	    code this;                  /* retrieved table entry */
    89	    unsigned op;                /* code bits, operation, extra bits, or */
    90	                                /*  window position, window bytes to copy */
    91	    unsigned len;               /* match length, unused bytes */
    92	    unsigned dist;              /* match distance */
    93	    unsigned char *from;        /* where to copy match from */
    94	
    95	    /* copy state to local variables */
    96	    state = (struct inflate_state *)strm->state;
    97	    in = strm->next_in;
    98	    last = in + (strm->avail_in - 5);
    99	    out = strm->next_out;
   100	    beg = out - (start - strm->avail_out);
   101	    end = out + (strm->avail_out - 257);
   102	#ifdef INFLATE_STRICT
   103	    dmax = state->dmax;
   104	#endif
   105	    wsize = state->wsize;
   106	    whave = state->whave;
   107	    write = state->write;
   108	    window = state->window;
   109	    hold = state->hold;
   110	    bits = state->bits;
   111	    lcode = state->lencode;
   112	    dcode = state->distcode;
   113	    lmask = (1U << state->lenbits) - 1;
   114	    dmask = (1U << state->distbits) - 1;
   115	
   116	    /* decode literals and length/distances until end-of-block or not enough
   117	       input data or output space */
   118	    do {
   119	        if (bits < 15) {
   120	            hold += (unsigned long)(*in++) << bits;
   121	            bits += 8;
   122	            hold += (unsigned long)(*in++) << bits;
   123	            bits += 8;
   124	        }
   125	        this = lcode[hold & lmask];
   126	      dolen:
   127	        op = (unsigned)(this.bits);
   128	        hold >>= op;
   129	        bits -= op;
   130	        op = (unsigned)(this.op);
   131	        if (op == 0) {                          /* literal */
   132	            *out++ = (unsigned char)(this.val);
   133	        }
   134	        else if (op & 16) {                     /* length base */
   135	            len = (unsigned)(this.val);
   136	            op &= 15;                           /* number of extra bits */
   137	            if (op) {
   138	                if (bits < op) {
   139	                    hold += (unsigned long)(*in++) << bits;
   140	                    bits += 8;
   141	                }
   142	                len += (unsigned)hold & ((1U << op) - 1);
   143	                hold >>= op;
   144	                bits -= op;
   145	            }
   146	            if (bits < 15) {
   147	                hold += (unsigned long)(*in++) << bits;
   148	                bits += 8;
   149	                hold += (unsigned long)(*in++) << bits;
   150	                bits += 8;
   151	            }
   152	            this = dcode[hold & dmask];
   153	          dodist:
   154	            op = (unsigned)(this.bits);
   155	            hold >>= op;
   156	            bits -= op;
   157	            op = (unsigned)(this.op);
   158	            if (op & 16) {                      /* distance base */
   159	                dist = (unsigned)(this.val);
   160	                op &= 15;                       /* number of extra bits */
   161	                if (bits < op) {
   162	                    hold += (unsigned long)(*in++) << bits;
   163	                    bits += 8;
   164	                    if (bits < op) {
   165	                        hold += (unsigned long)(*in++) << bits;
   166	                        bits += 8;
   167	                    }
   168	                }
   169	                dist += (unsigned)hold & ((1U << op) - 1);
   170	#ifdef INFLATE_STRICT
   171	                if (dist > dmax) {
   172	                    strm->msg = (char *)"invalid distance too far back";
   173	                    state->mode = BAD;
   174	                    break;
   175	                }
   176	#endif
   177	                hold >>= op;
   178	                bits -= op;
   179	                op = (unsigned)(out - beg);     /* max distance in output */
   180	                if (dist > op) {                /* see if copy from window */
   181	                    op = dist - op;             /* distance back in window */
   182	                    if (op > whave) {
   183	                        strm->msg = (char *)"invalid distance too far back";
   184	                        state->mode = BAD;
   185	                        break;
   186	                    }
   187	                    from = window;
   188	                    if (write == 0) {           /* very common case */
   189	                        from += wsize - op;
   190	                        if (op < len) {         /* some from window */
   191	                            len -= op;
   192	                            do {
   193	                                *out++ = *from++;
   194	                            } while (--op);
   195	                            from = out - dist;  /* rest from output */
   196	                        }
   197	                    }
   198	                    else if (write < op) {      /* wrap around window */
   199	                        from += wsize + write - op;
   200	                        op -= write;
   201	                        if (op < len) {         /* some from end of window */
   202	                            len -= op;
   203	                            do {
   204	                                *out++ = *from++;
   205	                            } while (--op);
   206	                            from = window;
   207	                            if (write < len) {  /* some from start of window */
   208	                                op = write;
   209	                                len -= op;
   210	                                do {
   211	                                    *out++ = *from++;
   212	                                } while (--op);
   213	                                from = out - dist;      /* rest from output */
   214	                            }
   215	                        }
   216	                    }
   217	                    else {                      /* contiguous in window */
   218	                        from += write - op;
   219	                        if (op < len) {         /* some from window */
   220	                            len -= op;
   221	                            do {
   222	                                *out++ = *from++;
   223	                            } while (--op);
   224	                            from = out - dist;  /* rest from output */
   225	                        }
   226	                    }
   227	                    while (len > 2) {
   228	                        *out++ = *from++;
   229	                        *out++ = *from++;
   230	                        *out++ = *from++;
   231	                        len -= 3;
   232	                    }
   233	                    if (len) {
   234	                        *out++ = *from++;
   235	                        if (len > 1)
   236	                            *out++ = *from++;
   237	                    }
   238	                }
   239	                else {
   240			    unsigned short *sout;
   241			    unsigned long loops;
   242	
   243	                    from = out - dist;          /* copy direct from output */
   244			    /* minimum length is three */
   245			    /* Align out addr */
   246			    if (!((long)(out - 1) & 1)) {
   247				*out++ = *from++;
   248				len--;
   249			    }
   250			    sout = (unsigned short *)(out);
   251			    if (dist > 2) {
   252				unsigned short *sfrom;
   253	
   254				sfrom = (unsigned short *)(from);
   255				loops = len >> 1;
   256				do
 > 257				    *sout++ = CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS ? *sfrom++ : get_unaligned16(sfrom++);
   258				while (--loops);
   259				out = (unsigned char *)sout;
   260				from = (unsigned char *)sfrom;
   261			    } else { /* dist == 1 or dist == 2 */
   262				unsigned short pat16;
   263	
   264				pat16 = *(sout-1);
   265				if (dist == 1) {
   266					union uu mm;
   267					/* copy one char pattern to both bytes */
   268					mm.us = pat16;
   269					mm.b[0] = mm.b[1];
   270					pat16 = mm.us;
   271				}
   272				loops = len >> 1;
   273				do
   274				    *sout++ = pat16;
   275				while (--loops);
   276				out = (unsigned char *)sout;
   277			    }
   278			    if (len & 1)
   279				*out++ = *from++;
   280	                }
   281	            }
   282	            else if ((op & 64) == 0) {          /* 2nd level distance code */
   283	                this = dcode[this.val + (hold & ((1U << op) - 1))];
   284	                goto dodist;
   285	            }
   286	            else {
   287	                strm->msg = (char *)"invalid distance code";
   288	                state->mode = BAD;
   289	                break;
   290	            }
   291	        }
   292	        else if ((op & 64) == 0) {              /* 2nd level length code */
   293	            this = lcode[this.val + (hold & ((1U << op) - 1))];
   294	            goto dolen;
   295	        }
   296	        else if (op & 32) {                     /* end-of-block */
   297	            state->mode = TYPE;
   298	            break;
   299	        }
   300	        else {
   301	            strm->msg = (char *)"invalid literal/length code";
   302	            state->mode = BAD;
   303	            break;
   304	        }
   305	    } while (in < last && out < end);
   306	
   307	    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
   308	    len = bits >> 3;
   309	    in -= len;
   310	    bits -= len << 3;
   311	    hold &= (1U << bits) - 1;
   312	
   313	    /* update state and return */
   314	    strm->next_in = in;
   315	    strm->next_out = out;
   316	    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
   317	    strm->avail_out = (unsigned)(out < end ?
   318	                                 257 + (end - out) : 257 - (out - end));
   319	    state->hold = hold;
   320	    state->bits = bits;
   321	    return;
   322	}
   323	

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

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 28632 bytes --]