drivers/pci/hotplug/cpqphp.h

236

u8 base_type[0x06];

drivers/pci/hotplug/cpqphp_pci.c

1124

if (func->base_type[(cloop - 0x10) >> 2] != type)

drivers/pci/hotplug/cpqphp_pci.c

615

func->base_type[(cloop - 0x10) >> 2] = type;

drivers/pci/hotplug/cpqphp_pci.c

654

func->base_type[(cloop - 0x10) >> 2] = type;

drivers/pinctrl/bcm/pinctrl-nsp-gpio.c

116

static inline bool nsp_get_bit(struct nsp_gpio *chip, enum base_type address,

drivers/pinctrl/bcm/pinctrl-nsp-gpio.c

92

static inline void nsp_set_bit(struct nsp_gpio *chip, enum base_type address,

drivers/spi/spi-bcm-qspi.c

303

static inline u32 bcm_qspi_read(struct bcm_qspi *qspi, enum base_type type,

drivers/spi/spi-bcm-qspi.c

310

static inline void bcm_qspi_write(struct bcm_qspi *qspi, enum base_type type,

include/linux/bpf_verifier.h

1310

return base_type(type) == PTR_TO_BTF_ID && type_flag(type) & MEM_ALLOC;

include/linux/bpf_verifier.h

1320

type = base_type(type);

kernel/bpf/btf.c

6969

type = base_type(ctx_arg_info->reg_type);

kernel/bpf/log.c

429

if (base_type(type) == PTR_TO_BTF_ID)

kernel/bpf/log.c

446

prefix, str[base_type(type)], postfix);

kernel/bpf/log.c

619

switch (base_type(t)) {

kernel/bpf/log.c

661

if (base_type(t) == PTR_TO_BTF_ID)

kernel/bpf/log.c

687

if (base_type(t) == PTR_TO_MEM) {

kernel/bpf/states.c

542

switch (base_type(rold->type)) {

kernel/bpf/verifier.c

10427

switch (base_type(ret_type)) {

kernel/bpf/verifier.c

10543

base_type(ret_type), func_id_name(func_id),

kernel/bpf/verifier.c

10553

base_type(ret_type), func_id_name(func_id), func_id);

kernel/bpf/verifier.c

11333

if ((base_type(reg->type) == PTR_TO_BTF_ID || reg2btf_ids[base_type(reg->type)])) {

kernel/bpf/verifier.c

11376

if (base_type(reg->type) == PTR_TO_BTF_ID) {

kernel/bpf/verifier.c

11381

reg_ref_id = *reg2btf_ids[base_type(reg->type)];

kernel/bpf/verifier.c

12346

if ((base_type(reg->type) != PTR_TO_BTF_ID ||

kernel/bpf/verifier.c

12348

!reg2btf_ids[base_type(reg->type)]) {

kernel/bpf/verifier.c

12352

reg_type_str(env, base_type(reg->type) |

kernel/bpf/verifier.c

12572

switch (base_type(at)) {

kernel/bpf/verifier.c

12575

bool is_key = base_type(at) == ARG_PTR_TO_MAP_KEY;

kernel/bpf/verifier.c

12580

if (base_type(fn->arg_type[i]) == ARG_CONST_MAP_PTR)

kernel/bpf/verifier.c

13716

if (base_type(ptr_reg->type) == PTR_TO_MEM && (ptr_reg->type & PTR_UNTRUSTED))

kernel/bpf/verifier.c

13719

switch (base_type(ptr_reg->type)) {

kernel/bpf/verifier.c

16133

base_type(src_reg->type) != PTR_TO_BTF_ID &&

kernel/bpf/verifier.c

16134

base_type(dst_reg->type) != PTR_TO_BTF_ID) {

kernel/bpf/verifier.c

16219

switch (base_type(dst_reg->type)) {

kernel/bpf/verifier.c

16982

switch (base_type(type)) {

kernel/bpf/verifier.c

17016

switch (base_type(type)) {

kernel/bpf/verifier.c

17027

return base_type(type) == PTR_TO_MEM;

kernel/bpf/verifier.c

18432

} else if (base_type(arg->arg_type) == ARG_PTR_TO_MEM) {

kernel/bpf/verifier.c

18440

} else if (base_type(arg->arg_type) == ARG_PTR_TO_BTF_ID) {

kernel/bpf/verifier.c

18452

} else if (base_type(arg->arg_type) == ARG_PTR_TO_ARENA) {

kernel/bpf/verifier.c

1877

if (base_type(reg->type) == PTR_TO_MAP_VALUE) {

kernel/bpf/verifier.c

1926

return base_type(reg->type) == PTR_TO_MEM &&

kernel/bpf/verifier.c

3310

switch (base_type(type)) {

kernel/bpf/verifier.c

369

type = base_type(type);

kernel/bpf/verifier.c

4296

if (base_type(reg->type) != PTR_TO_BTF_ID)

kernel/bpf/verifier.c

4693

if (base_type(info->reg_type) == PTR_TO_BTF_ID) {

kernel/bpf/verifier.c

4883

if (reg2btf_ids[base_type(reg->type)] &&

kernel/bpf/verifier.c

6159

} else if (base_type(reg->type) == PTR_TO_MEM) {

kernel/bpf/verifier.c

6229

if (base_type(info.reg_type) == PTR_TO_BTF_ID) {

kernel/bpf/verifier.c

6290

} else if (base_type(reg->type) == PTR_TO_BTF_ID &&

kernel/bpf/verifier.c

6297

} else if (base_type(reg->type) == PTR_TO_BUF &&

kernel/bpf/verifier.c

6749

switch (base_type(reg->type)) {

kernel/bpf/verifier.c

6913

int size = base_type(reg->type) == PTR_TO_STACK ? -(int)mem_size : mem_size;

kernel/bpf/verifier.c

7675

return base_type(type) == ARG_PTR_TO_MEM &&

kernel/bpf/verifier.c

7686

return base_type(type) == ARG_PTR_TO_DYNPTR;

kernel/bpf/verifier.c

7842

compatible = compatible_reg_types[base_type(arg_type)];

kernel/bpf/verifier.c

7864

if (base_type(arg_type) == ARG_PTR_TO_MEM)

kernel/bpf/verifier.c

7889

if (base_type(reg->type) != PTR_TO_BTF_ID)

kernel/bpf/verifier.c

8247

if (base_type(arg_type) == ARG_PTR_TO_MAP_VALUE) {

kernel/bpf/verifier.c

8260

if (base_type(arg_type) == ARG_PTR_TO_BTF_ID ||

kernel/bpf/verifier.c

8261

base_type(arg_type) == ARG_PTR_TO_SPIN_LOCK)

kernel/bpf/verifier.c

8283

switch (base_type(arg_type)) {

kernel/bpf/verifier.c

8781

if (base_type(fn->arg_type[arg]) != ARG_PTR_TO_MEM)

kernel/bpf/verifier.c

8810

if (base_type(fn->arg_type[i]) == ARG_PTR_TO_BTF_ID)

kernel/bpf/verifier.c

8812

if (base_type(fn->arg_type[i]) == ARG_PTR_TO_SPIN_LOCK)

kernel/bpf/verifier.c

8814

if (base_type(fn->arg_type[i]) != ARG_PTR_TO_BTF_ID && fn->arg_btf_id[i] &&

kernel/bpf/verifier.c

8816

(base_type(fn->arg_type[i]) != ARG_PTR_TO_MEM ||

kernel/bpf/verifier.c

8831

if (base_type(arg_type) != ARG_PTR_TO_MEM)

kernel/bpf/verifier.c

9186

} else if (base_type(arg->arg_type) == ARG_PTR_TO_MEM) {

kernel/bpf/verifier.c

9198

} else if (base_type(arg->arg_type) == ARG_PTR_TO_ARENA) {

kernel/bpf/verifier.c

9219

} else if (base_type(arg->arg_type) == ARG_PTR_TO_BTF_ID) {

net/ipv4/bpf_tcp_ca.c

52

if (base_type(info->reg_type) == PTR_TO_BTF_ID &&

tools/testing/selftests/bpf/veristat.c

2019

const struct btf_type *base_type;

tools/testing/selftests/bpf/veristat.c

2028

base_type = btf__type_by_id(btf, tid);

tools/testing/selftests/bpf/veristat.c

2039

err = adjust_var_secinfo_member(btf, base_type, 0, atom->name, sinfo);

tools/testing/selftests/bpf/veristat.c

2050

base_type = btf__type_by_id(btf, sinfo->type);

tools/testing/selftests/bpf/veristat.c

2061

const struct btf_type *base_type;

tools/testing/selftests/bpf/veristat.c

2066

base_type = btf__type_by_id(btf, btf__resolve_type(btf, sinfo->type));

tools/testing/selftests/bpf/veristat.c

2067

if (!base_type) {

tools/testing/selftests/bpf/veristat.c

2071

if (!is_preset_supported(base_type)) {

tools/testing/selftests/bpf/veristat.c

2078

if (btf_is_any_enum(base_type)) {

tools/testing/selftests/bpf/veristat.c

2079

if (enum_value_from_name(btf, base_type, preset->value.svalue, &value)) {

tools/testing/selftests/bpf/veristat.c

2088

btf__name_by_offset(btf, base_type->name_off));

tools/testing/selftests/bpf/veristat.c

2095

bool is_signed = is_signed_type(base_type);

tools/testing/selftests/bpf/veristat.c

2102

btf__name_by_offset(btf, base_type->name_off), value,