File Coverage

src/int/i31_decmod.c
Criterion Covered Total %
statement 33 34 97.0
branch 15 16 93.7
condition n/a
subroutine n/a
pod n/a
total 48 50 96.0


line stmt bran cond sub pod time code
1             /*
2             * Copyright (c) 2016 Thomas Pornin
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 6           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 6           buf = src;
60 6           mlen = (m[0] + 31) >> 5;
61 6           tlen = (mlen << 2);
62 6 50         if (tlen < len) {
63 0           tlen = len;
64             }
65 6           tlen += 4;
66 6           r = 0;
67 18 100         for (pass = 0; pass < 2; pass ++) {
68             size_t u, v;
69             uint32_t acc;
70             int acc_len;
71              
72 12           v = 1;
73 12           acc = 0;
74 12           acc_len = 0;
75 1356 100         for (u = 0; u < tlen; u ++) {
76             uint32_t b;
77              
78 1344 100         if (u < len) {
79 1216           b = buf[len - 1 - u];
80             } else {
81 128           b = 0;
82             }
83 1344           acc |= (b << acc_len);
84 1344           acc_len += 8;
85 1344 100         if (acc_len >= 31) {
86             uint32_t xw;
87              
88 344           xw = acc & (uint32_t)0x7FFFFFFF;
89 344           acc_len -= 31;
90 344           acc = b >> (8 - acc_len);
91 344 100         if (v <= mlen) {
92 324 100         if (pass) {
93 162           x[v] = r & xw;
94             } else {
95             uint32_t cc;
96              
97 162           cc = (uint32_t)CMP(xw, m[v]);
98 162           r = MUX(EQ(cc, 0), r, cc);
99             }
100             } else {
101 20 100         if (!pass) {
102 10           r = MUX(EQ(xw, 0), r, 1);
103             }
104             }
105 344           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 12           r >>= 1;
119 12           r |= (r << 1);
120             }
121              
122 6           x[0] = m[0];
123 6           return r & (uint32_t)1;
124             }