1  /*
  2   * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
  3   *
  4   * Permission is hereby granted, free of charge, to any person obtaining 
  5   * a copy of this software and associated documentation files (the
  6   * "Software"), to deal in the Software without restriction, including
  7   * without limitation the rights to use, copy, modify, merge, publish,
  8   * distribute, sublicense, and/or sell copies of the Software, and to
  9   * permit persons to whom the Software is furnished to do so, subject to
 10   * the following conditions:
 11   *
 12   * The above copyright notice and this permission notice shall be 
 13   * included in all copies or substantial portions of the Software.
 14   *
 15   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
 16   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 17   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 18   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 19   * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 20   * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 21   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 22   * SOFTWARE.
 23   */
 24  
 25  #include "inner.h"
 26  
 27  /* see inner.h */
 28  uint32_t
 29  br_i31_decode_mod(uint32_t *x, const void *src, size_t len, const uint32_t *m)
 30  {
 31  	/*
 32  	 * Two-pass algorithm: in the first pass, we determine whether the
 33  	 * value fits; in the second pass, we do the actual write.
 34  	 *
 35  	 * During the first pass, 'r' contains the comparison result so
 36  	 * far:
 37  	 *  0x00000000   value is equal to the modulus
 38  	 *  0x00000001   value is greater than the modulus
 39  	 *  0xFFFFFFFF   value is lower than the modulus
 40  	 *
 41  	 * Since we iterate starting with the least significant bytes (at
 42  	 * the end of src[]), each new comparison overrides the previous
 43  	 * except when the comparison yields 0 (equal).
 44  	 *
 45  	 * During the second pass, 'r' is either 0xFFFFFFFF (value fits)
 46  	 * or 0x00000000 (value does not fit).
 47  	 *
 48  	 * We must iterate over all bytes of the source, _and_ possibly
 49  	 * some extra virtual bytes (with value 0) so as to cover the
 50  	 * complete modulus as well. We also add 4 such extra bytes beyond
 51  	 * the modulus length because it then guarantees that no accumulated
 52  	 * partial word remains to be processed.
 53  	 */
 54  	const unsigned char *buf;
 55  	size_t mlen, tlen;
 56  	int pass;
 57  	uint32_t r;
 58  
 59  	buf = src;
 60  	mlen = (m[0] + 31) >> 5;
 61  	tlen = (mlen << 2);
 62  	if (tlen < len) {
 63  		tlen = len;
 64  	}
 65  	tlen += 4;
 66  	r = 0;
 67  	for (pass = 0; pass < 2; pass ++) {
 68  		size_t u, v;
 69  		uint32_t acc;
 70  		int acc_len;
 71  
 72  		v = 1;
 73  		acc = 0;
 74  		acc_len = 0;
 75  		for (u = 0; u < tlen; u ++) {
 76  			uint32_t b;
 77  
 78  			if (u < len) {
 79  				b = buf[len - 1 - u];
 80  			} else {
 81  				b = 0;
 82  			}
 83  			acc |= (b << acc_len);
 84  			acc_len += 8;
 85  			if (acc_len >= 31) {
 86  				uint32_t xw;
 87  
 88  				xw = acc & (uint32_t)0x7FFFFFFF;
 89  				acc_len -= 31;
 90  				acc = b >> (8 - acc_len);
 91  				if (v <= mlen) {
 92  					if (pass) {
 93  						x[v] = r & xw;
 94  					} else {
 95  						uint32_t cc;
 96  
 97  						cc = (uint32_t)CMP(xw, m[v]);
 98  						r = MUX(EQ(cc, 0), r, cc);
 99  					}
100  				} else {
101  					if (!pass) {
102  						r = MUX(EQ(xw, 0), r, 1);
103  					}
104  				}
105  				v ++;
106  			}
107  		}
108  
109  		/*
110  		 * When we reach this point at the end of the first pass:
111  		 * r is either 0, 1 or -1; we want to set r to 0 if it
112  		 * is equal to 0 or 1, and leave it to -1 otherwise.
113  		 *
114  		 * When we reach this point at the end of the second pass:
115  		 * r is either 0 or -1; we want to leave that value
116  		 * untouched. This is a subcase of the previous.
117  		 */
118  		r >>= 1;
119  		r |= (r << 1);
120  	}
121  
122  	x[0] = m[0];
123  	return r & (uint32_t)1;
124  }