Lines Matching defs:range

87  * and the range of [ptr, ptr + map's value_size) is accessible.

596                 verbose(env, ",r=%d", reg->range);

1027     /* Clear id, off, and union(map_ptr, range) */

1081     /* The register can already have a range from prior markings.

1321      * Clear type, id, off, and union(map_ptr, range) and

1511             verbose(env, "jump out of range from insn %d to %d\n", i, off);

2398  * dynamic range is potentially written to.

2404  * Spilled pointers in range are not marked as written because we don't know

2444     /* Variable offset writes destroy any spilled pointers in range. */

2455              * range. If we didn't reject here, the ptr status

2460             verbose(env, "spilled ptr in range of var-offset stack write; insn %d, ptr off: %d", insn_idx, i);

2482             verbose(env, "uninit stack in range of var-offset write prohibited for !root; insn %d, off: %d", insn_idx,

2503  * ensure that all spilled registers in the stack range have been marked as

2830      * will have a set floor within our range.

2840         verbose(env, "R%d min value is outside of the allowed memory range\n", regno);

2854         verbose(env, "R%d max value is outside of the allowed memory range\n", regno);

2949      * reg->range we have comes after that.  We are only checking the fixed

2960     err = __check_mem_access(env, regno, off, size, reg->range, zero_size_allowed);

2968      * otherwise find_good_pkt_pointers would have refused to set range info

4125  * the range of access to valid map value pointer and doesn't care about actual

5808      * masking when off was not within expected range. If off

5894                 "R%d stack pointer arithmetic goes out of range, "

5924                         "R%d pointer arithmetic of map value goes out of range, "

6071                 /* something was added to pkt_ptr, set range to zero */

6102              * nonnegative, then any reg->range we had before is still good.

6126                 /* something was added to pkt_ptr, set range to zero */

6911                  * src/dest handling in computing the range

7026                      * to propagate min/max range.

7126             /* keep the maximum range already checked */

7127             reg->range = max(reg->range, new_range);

7137             reg->range = max(reg->range, new_range);

7149         /* This doesn't give us any range */

7201      * Find register r3 and mark its range as r3=pkt(id=n,off=0,r=8)

7202      * or r3=pkt(id=n,off=0,r=8-1), so that range of bytes [r3, r3 + 8)

7209      * the range won't allow anything.

7391  *      range [0,10]

8165     struct tnum range = tnum_range(0, 1);

8210                 range = tnum_range(1, 1);

8215                 range = tnum_range(0, 3);

8229             range = tnum_const(0);

8235                     range = tnum_const(0);

8247             range = tnum_range(SK_DROP, SK_PASS);

8262     if (!tnum_in(range, reg->var_off)) {

8272         tnum_strn(tn_buf, sizeof(tn_buf), range);

8361         verbose(env, "jump out of range from insn %d to %d\n", t, w);

8843 /* check %cur's range satisfies %old's */

9067             /* We must have at least as much range as the old ptr

9069              * still safe.  This is true even if old range < old off,

9073             if (rold->range > rcur->range) {

9077              * nor can we be sure that we won't fall out of range.

10327 /* single env->prog->insni[off] instruction was replaced with the range

10329  * [0, off) and [off, end) to new locations, so the patched range stays zero

10354         /* Expand insni[off]'s seen count to the patched range. */

10409             verbose(env, "insn %d cannot be patched due to 16-bit range\n", env->insn_aux_data[off].orig_idx);