drivers/message/fusion/lsi/mpi_type.h

79

typedef S64 *PS64;

kernel/trace/trace_events_hist.c

122

C(S64, "s64"), \

lib/zstd/compress/zstd_compress.c

4466

static size_t ZSTD_optimalBlockSize(ZSTD_CCtx* cctx, const void* src, size_t srcSize, size_t blockSizeMax, int splitLevel, ZSTD_strategy strat, S64 savings)

lib/zstd/compress/zstd_compress.c

4516

S64 savings = (S64)cctx->consumedSrcSize - (S64)cctx->producedCSize;

lib/zstd/compress/zstd_compress.c

4591

savings += (S64)blockSize - (S64)cSize;

lib/zstd/compress/zstd_preSplit.c

103

abs64((S64)fp1->events[n] * (S64)fp2->nbEvents - (S64)fp2->events[n] * (S64)fp1->nbEvents);

lib/zstd/compress/zstd_preSplit.c

223

if (abs64((S64)distFromBegin - (S64)distFromEnd) < minDistance)

lib/zstd/compress/zstd_preSplit.c

94

static U64 abs64(S64 s64) { return (U64)((s64 < 0) ? -s64 : s64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

105

case S64: return "s64";

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1098

{"smin=", &reg->r[S64].a, S64_MIN},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1099

{"smax=", &reg->r[S64].b, S64_MAX},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

116

case S64: return false;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

125

case U64: return S64;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

127

case S64: return S64;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

138

case S64: return U64;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1451

.setup_signed = (init_t == S64 || init_t == S32),

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1453

.compare_signed = (cond_t == S64 || cond_t == S32),

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

153

case S64: return (s64)x >= SNUM_MIN_DECIMAL && (s64)x <= SNUM_MAX_DECIMAL;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1632

snprintf_num(S64, sb2, ctx->svals[i]);

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

167

case S64: return snappendf(sb, "%lld", (s64)x);

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1683

snprintf_range(S64, sb2, range(S64, ctx->svals[i], ctx->svals[j]));

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1702

ctx->sranges[cnt] = range(S64, ctx->svals[i], ctx->svals[j]);

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

187

case S64:

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1903

case S64:

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1947

void test_reg_bounds_gen_consts_u64_s64(void) { validate_gen_range_vs_const_64(U64, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1951

void test_reg_bounds_gen_consts_s64_u64(void) { validate_gen_range_vs_const_64(S64, U64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1952

void test_reg_bounds_gen_consts_s64_s64(void) { validate_gen_range_vs_const_64(S64, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1953

void test_reg_bounds_gen_consts_s64_u32(void) { validate_gen_range_vs_const_64(S64, U32); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1954

void test_reg_bounds_gen_consts_s64_s32(void) { validate_gen_range_vs_const_64(S64, S32); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1957

void test_reg_bounds_gen_consts_u32_s64(void) { validate_gen_range_vs_const_32(U32, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1962

void test_reg_bounds_gen_consts_s32_s64(void) { validate_gen_range_vs_const_32(S32, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1968

void test_reg_bounds_gen_ranges_u64_s64(void) { validate_gen_range_vs_range(U64, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1972

void test_reg_bounds_gen_ranges_s64_u64(void) { validate_gen_range_vs_range(S64, U64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1973

void test_reg_bounds_gen_ranges_s64_s64(void) { validate_gen_range_vs_range(S64, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1974

void test_reg_bounds_gen_ranges_s64_u32(void) { validate_gen_range_vs_range(S64, U32); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1975

void test_reg_bounds_gen_ranges_s64_s32(void) { validate_gen_range_vs_range(S64, S32); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1978

void test_reg_bounds_gen_ranges_u32_s64(void) { validate_gen_range_vs_range(U32, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1983

void test_reg_bounds_gen_ranges_s32_s64(void) { validate_gen_range_vs_range(S32, S64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2068

void test_reg_bounds_rand_consts_u64_s64(void) { validate_rand_ranges(U64, S64, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2072

void test_reg_bounds_rand_consts_s64_u64(void) { validate_rand_ranges(S64, U64, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2073

void test_reg_bounds_rand_consts_s64_s64(void) { validate_rand_ranges(S64, S64, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2074

void test_reg_bounds_rand_consts_s64_u32(void) { validate_rand_ranges(S64, U32, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2075

void test_reg_bounds_rand_consts_s64_s32(void) { validate_rand_ranges(S64, S32, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2078

void test_reg_bounds_rand_consts_u32_s64(void) { validate_rand_ranges(U32, S64, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2083

void test_reg_bounds_rand_consts_s32_s64(void) { validate_rand_ranges(S32, S64, true /* const */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2089

void test_reg_bounds_rand_ranges_u64_s64(void) { validate_rand_ranges(U64, S64, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2093

void test_reg_bounds_rand_ranges_s64_u64(void) { validate_rand_ranges(S64, U64, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2094

void test_reg_bounds_rand_ranges_s64_s64(void) { validate_rand_ranges(S64, S64, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2095

void test_reg_bounds_rand_ranges_s64_u32(void) { validate_rand_ranges(S64, U32, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2096

void test_reg_bounds_rand_ranges_s64_s32(void) { validate_rand_ranges(S64, S32, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2099

void test_reg_bounds_rand_ranges_u32_s64(void) { validate_rand_ranges(U32, S64, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2104

void test_reg_bounds_rand_ranges_s32_s64(void) { validate_rand_ranges(S32, S64, false /* range */); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2123

{U64, S64, {0, 1}, {1, 0x80000000}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2127

{U64, S64, {0, 0xffffffff00000000ULL}, {0, 0}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2128

{U64, S64, {0x7fffffffffffffffULL, 0xffffffff00000000ULL}, {0, 0}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2129

{U64, S64, {0x7fffffff00000001ULL, 0xffffffff00000000ULL}, {0, 0}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2130

{U64, S64, {0, 0xffffffffULL}, {1, 1}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2131

{U64, S64, {0, 0xffffffffULL}, {0x7fffffff, 0x7fffffff}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2148

{S64, S64, {0xffffffffffffffffULL, 0}, {0xffffffff00000000ULL, 0xffffffff00000000ULL}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2156

{S64, U64, {0xffffffff00000001ULL, 0}, {0xffffffff00000000ULL, 0xffffffff00000000ULL}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2163

{S32, S64, {(u32)S32_MIN, (u32)(s32)-255}, {(u32)(s32)-2, 0}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2164

{S32, S64, {0, 1}, {(u32)S32_MIN, (u32)S32_MIN}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2170

{S64, U64, {S64_MIN, 0}, {S64_MIN, S64_MIN}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2171

{S64, U64, {S64_MIN, 0}, {0, 0}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2172

{S64, U64, {S64_MIN, S64_MAX}, {S64_MAX, S64_MAX}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2178

{S64, U32, {0x0, 0x1f}, {0xffffffff80000000ULL, 0x000000007fffffffULL}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2179

{S64, U32, {0x0, 0x1f}, {0xffffffffffff8000ULL, 0x0000000000007fffULL}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

2180

{S64, U32, {0x0, 0x1f}, {0xffffffffffffff80ULL, 0x000000000000007fULL}},

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

245

[S64] = { (u64)S64_MIN, (u64)S64_MAX },

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

254

case S64: return unkn[U32];

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

265

case S64: return (struct range){ (s64)a, (s64)b };

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

318

case S64:

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

320

return unkn[S64];

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

321

return range(S64, a, b);

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

342

case S64:

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

356

case S64:

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

374

case S64:

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

394

case S64: return range_cast_s64(to_t, from);

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

405

case S64: return true;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

419

case S64: return (s64)x.a <= (s64)x.b;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

499

if (x_t == S64 && y_t == S32 && y_cast.a <= S32_MAX && y_cast.b <= S32_MAX &&

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

580

case S64: { range_canbe(s64); }

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

72

case S64: return (s64)x < (s64)y ? (s64)x : (s64)y;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

83

case S64: return (s64)x > (s64)y ? (s64)x : (s64)y;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

842

if (br_u == -1 && (t == U64 || t == S64)) {

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

94

case S64: return (s64)x;

tools/testing/selftests/proc/setns-sysvipc.c

125

} else if (rv == strlen(S64)) {

tools/testing/selftests/proc/setns-sysvipc.c

126

assert(memcmp(buf, S64, strlen(S64)) == 0);