[Clang] Ignore BTFTag attr if used as a type attribute

[yonghong-song]

Summary

Currently, linux kernel has a __user attribute ([1]) defined as

__attribute__((noderef, address_space(__user)))

which is used by sparse tool ([2]) to do some
type checking of pointers to user space memory.
During normal compilation, __user will be defined
to nothing so it won't have an impact on compilation.

The btf_tag attribute, which is motivated by
carrying linux kernel annotations into dwarf/BTF,
is introduced in [3]. We intended to define __user as

__attribute__((btf_tag("user")))

so such information will be encoded in dwarf/BTF
and can be used later by bpf verification or other
tracing tools.

But linux kernel __user attribute is also used during
type conversion which btf_tag doesn't support ([4]) since
such type conversion is only used for compiler analysis
and not encoded in dwarf/btf. Theoretically, it is
possible for clang to understand these tags and
do a sparse-like type checking work. But I would like
to leave that to future work and for now suggest simply
ignore these btf_tag attributes if they are used
as type attributes.

[1] https://github.com/torvalds/linux/blob/master/include/linux/compiler_types.h#L10
[2] https://sparse.docs.kernel.org/en/latest/
[3] https://reviews.llvm.org/D106614
[4] https://github.com/torvalds/linux/blob/master/fs/binfmt_flat.c#L135

[aaron.ballman]

clang/lib/Sema/SemaType.cpp

8130

Errr, this attribute isn't a type attribute in the first place, so I'd feel more comfortable if this was also modified in Attr.td to be a DeclOrTypeAttr instead of an InheritableAttr.

There should also be a change to AttrDocs.td to explain what's going on.

clang/test/Sema/attr-btf_tag.c

45

I'd appreciate a FIXME comment here about why this is silently accepted but does nothing.

[yonghong-song]

• change to use DeclOrTypeAttr in Attr.td to indicate the attribute can be used for declarations or type qualifier.
• add explanation of why the change in AttrDocs.td and the test.

[yonghong-song]

@aaron.ballman Addressed your comments, please take a look. Thanks!

[aaron.ballman]

LGTM aside from a minor nit with documentation grammar.

clang/include/clang/Basic/AttrDocs.td

2024

[yonghong-song]

• to adjust some wording in AttrDocs.td based on Aaron's suggestion.

clang/include/clang/Basic/Attr.td

 def BPFPreserveAccessIndex : InheritableAttr,
                              TargetSpecificAttr<TargetBPF>  {
   let Spellings = [Clang<"preserve_access_index">];
   let Subjects = SubjectList<[Record], ErrorDiag>;
   let Documentation = [BPFPreserveAccessIndexDocs];
   let LangOpts = [COnly];
 }
 
-def BTFTag : InheritableAttr {
+def BTFTag : DeclOrTypeAttr {
   let Spellings = [Clang<"btf_tag">];
   let Args = [StringArgument<"BTFTag">];
   let Subjects = SubjectList<[Var, Function, Record, Field], ErrorDiag>;
   let Documentation = [BTFTagDocs];
   let LangOpts = [COnly];
 }
 
 def WebAssemblyExportName : InheritableAttr,

clang/include/clang/Basic/AttrDocs.td

 def BTFTagDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the ``__attribute__((btf_tag("ARGUMENT")))`` attribute for all
 targets. This attribute may be attached to a struct/union, struct/union field,
 function, function parameter or variable declaration. If -g is specified,
 the ``ARGUMENT`` info will be preserved in IR and be emitted to dwarf.
 For BPF targets, the ``ARGUMENT`` info will be emitted to .BTF ELF section too.
+
+The attribute can also be used as a type qualifier. Right now it is accepted
+and silently ignored in order to permit the linux kernel to build with the
+attribute.
   }];
 }
 
 def MipsInterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "interrupt (MIPS)";
   let Content = [{
 Clang supports the GNU style ``__attribute__((interrupt("ARGUMENT")))`` attribute on

clang/lib/AST/TypePrinter.cpp

#include "clang/Basic/AttrList.inc"
   case attr::ObjCKindOf:
   case attr::ObjCOwnership:
   case attr::Ptr32:
   case attr::Ptr64:
   case attr::SPtr:
   case attr::UPtr:
   case attr::AddressSpace:
   case attr::CmseNSCall:
+  case attr::BTFTag:
     llvm_unreachable("This attribute should have been handled already");
 
   case attr::NSReturnsRetained:
     OS << "ns_returns_retained";
     break;
 
   // FIXME: When Sema learns to form this AttributedType, avoid printing the
   // attribute again in printFunctionProtoAfter.

clang/lib/Sema/SemaType.cpp

case ParsedAttr::UnknownAttribute:
         state.getSema().Diag(attr.getLoc(),
                              diag::warn_unknown_attribute_ignored)
             << attr << attr.getRange();
       break;
 
     case ParsedAttr::IgnoredAttribute:
       break;
 
+    case ParsedAttr::AT_BTFTag:
+      // FIXME: Linux kernel may also use this attribute for type casting check,
+      // which clang doesn's support for now. Let us ignore them so linux kernel
+      // build won't break.
+      attr.setUsedAsTypeAttr();
+      break;
     case ParsedAttr::AT_MayAlias:
       // FIXME: This attribute needs to actually be handled, but if we ignore
       // it it breaks large amounts of Linux software.
       attr.setUsedAsTypeAttr();
       break;
     case ParsedAttr::AT_OpenCLPrivateAddressSpace:
     case ParsedAttr::AT_OpenCLGlobalAddressSpace:
     case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:

clang/test/Sema/attr-btf_tag.c

enum e3 {
   E3
 } __tag_2_arg; // expected-error {{'btf_tag' attribute only applies to variables, functions, structs, unions, classes, and non-static data members}}
 
 int __tag1 __tag2 foo(struct t1 *arg, struct t2 *arg2);
 int __tag2 __tag3 foo(struct t1 *arg, struct t2 *arg2);
 int __tag1 foo(struct t1 *arg __tag1, struct t2 *arg2) {
   return arg->a + arg2->a;
 }
+
+void * convert(long arg) {
+  /* FIXME: the attribute __tag1 is accepted but didn't really do type conversion
+   * or enforce type checking. This is to permit linux kernel build with btf_tag
+   * attribute.
+   */
+  return (void __tag1 *)arg;
+}