__btf_verifier_log(log, "[%u] %s %s%s",
                           env->log_type_id,
                           btf_kind_str[kind],
-                          btf_name_by_offset(btf, t->name),
+                          btf_name_by_offset(btf, t->name_off),
                           log_details ? " " : "");
 
        if (log_details)
                btf_verifier_log_type(env, struct_type, NULL);
 
        __btf_verifier_log(log, "\t%s type_id=%u bits_offset=%u",
-                          btf_name_by_offset(btf, member->name),
+                          btf_name_by_offset(btf, member->name_off),
                           member->type, member->offset);
 
        if (fmt && *fmt) {
        btf_verifier_log_type(env, t, NULL);
 
        for_each_member(i, t, member) {
-               if (!btf_name_offset_valid(btf, member->name)) {
+               if (!btf_name_offset_valid(btf, member->name_off)) {
                        btf_verifier_log_member(env, t, member,
                                                "Invalid member name_offset:%u",
-                                               member->name);
+                                               member->name_off);
                        return -EINVAL;
                }
 
        btf_verifier_log_type(env, t, NULL);
 
        for (i = 0; i < nr_enums; i++) {
-               if (!btf_name_offset_valid(btf, enums[i].name)) {
+               if (!btf_name_offset_valid(btf, enums[i].name_off)) {
                        btf_verifier_log(env, "\tInvalid name_offset:%u",
-                                        enums[i].name);
+                                        enums[i].name_off);
                        return -EINVAL;
                }
 
                btf_verifier_log(env, "\t%s val=%d\n",
-                                btf_name_by_offset(btf, enums[i].name),
+                                btf_name_by_offset(btf, enums[i].name_off),
                                 enums[i].val);
        }
 
        for (i = 0; i < nr_enums; i++) {
                if (v == enums[i].val) {
                        seq_printf(m, "%s",
-                                  btf_name_by_offset(btf, enums[i].name));
+                                  btf_name_by_offset(btf, enums[i].name_off));
                        return;
                }
        }
                return -EINVAL;
        }
 
-       if (!btf_name_offset_valid(env->btf, t->name)) {
+       if (!btf_name_offset_valid(env->btf, t->name_off)) {
                btf_verifier_log(env, "[%u] Invalid name_offset:%u",
-                                env->log_type_id, t->name);
+                                env->log_type_id, t->name_off);
                return -EINVAL;
        }