[clang] Add WriteOnly attribute

[homerdin]

Summary

This patch adds a WriteOnly attribute.

I am working to mark the math functions that write errno as WriteOnly in the backend to enable some optimizations. Currently I plan to use this attribute in SemaDecl to mark the math functions that may set errno when we care about errno. Then to add the llvm WriteOnly attribute in CGCall when a function adds this attribute.

Any feedback would be appreciated!

[aaron.ballman]

I am working to mark the math functions that write errno as WriteOnly in the backend to enable some optimizations. Currently I plan to use this attribute in SemaDecl to mark the math functions that may set errno when we care about errno. Then to add the llvm WriteOnly attribute in CGCall when a function adds this attribute.

Are you planning to mark the math functions explicitly by adding the attribute to their declarations, or are you planning to mark them implicitly from SemaDecl so that the libc headers don't have to add the annotation?

The patch is also missing plumbing such as adding the parsed attribute to the AST (in SemaDeclAttr.cpp), lowering it to LLVM, tests, etc, so it's a bit hard to understand the overall design you're going for.

include/clang/Basic/Attr.td

1784

What subjects should this attribute appertain to?

1785

Typically, this attribute would be named write_only_func instead.

1786

No new, undocumented attributes, please.

[homerdin]

Thanks for the feedback! I plan to mark the math function implicitly from SemaDecl. I am going to open this in a separate diff, but I still need to update some tests.

if (getLangOpts().MathErrno && !FD->hasAttr<ConstAttr>() &&
    Context.BuiltinInfo.isConstWithoutErrno(BuiltinID))
  FD->addAttr(WriteOnlyFuncAttr::CreateImplicit(Context, FD->getLocation()));

Let me know if there is any additional plumbing that should be added or if you have thoughts on the overall design.

[aaron.ballman]

In D46313#1091388, @homerdin wrote:

Thanks for the feedback! I plan to mark the math function implicitly from SemaDecl. I am going to open this in a separate diff, but I still need to update some tests.

if (getLangOpts().MathErrno && !FD->hasAttr<ConstAttr>() &&
    Context.BuiltinInfo.isConstWithoutErrno(BuiltinID))
  FD->addAttr(WriteOnlyFuncAttr::CreateImplicit(Context, FD->getLocation()));

Let me know if there is any additional plumbing that should be added or if you have thoughts on the overall design.

If I understand properly, which I might not, it sounds like users shouldn't be writing this attribute explicitly, but instead the attribute should only be applied implicitly under specific circumstances. Is that correct? If so, then I would consider one of two things: 0) forgo the AST-level attribute entirely and just lower to the LLVM IR attribute directly, or 1) do not use a Sema handler or spelling and instead use CreateImplicit to create the AST attribute as-needed (see MaxFieldAlignment for an example of this). If you do expect users to write this attribute manually, then I think the documentation needs more exposition because it's not really clear under what circumstances users should use this attribute, what will go wrong if they misapply it, what the effects of the attribute are, etc.

[homerdin]

Sorry about the slow turn around. I've updated the documentation to be clearer about this attribute's use.

While I'm mainly interested in marking math functions, exposing this attribute to users should be beneficial as I'm working to enable some optimizations in the backend making use of the WriteOnly LLVM attribute.

I haven't added any additional documentation concerning consequences and effects because at this point the WriteOnly LLVM attribute is not being used extensively. Would it be best to wait until additional uses (CSE, Hoisting) are in effect then update the documentation?

I've uploaded a diff that applies this attribute to libm functions when we care about errno: https://reviews.llvm.org/D48386

[aaron.ballman]

In D46313#1138098, @homerdin wrote:

Sorry about the slow turn around. I've updated the documentation to be clearer about this attribute's use.

While I'm mainly interested in marking math functions, exposing this attribute to users should be beneficial as I'm working to enable some optimizations in the backend making use of the WriteOnly LLVM attribute.

I haven't added any additional documentation concerning consequences and effects because at this point the WriteOnly LLVM attribute is not being used extensively. Would it be best to wait until additional uses (CSE, Hoisting) are in effect then update the documentation?

It's better to document things up front -- this makes it more likely that the attribute is used in practice because people know what it is, what it does, and when it's beneficial to use.

include/clang/Basic/Attr.td

1786

What happens if I apply this attribute to a virtual function such as in the following example:

int memory;

struct Base {
  [[clang::write_only_func]] virtual int f(int i) const { return memory = i; }
};

struct Derived1 : Base {
  int f(int i) const override { return memory =  i + 12; }
};

struct Derived2 : Base {
  int f(int i) const override { return memory = i + memory; }
};

Further -- what happens if you mark a function as write_only_func and it doesn't adhere to the statements in the documentation? e.g., should Derived2::f() generate a warning and drop the attribute?

include/clang/Basic/AttrDocs.td

3466

may write to but does not read from memory -> may write to, but does not read from, memory

A write only -> a write-only

3467

writes memory the same

Does this mean it writes the same value to the same memory location when called with the same set of arguments and global state? If so, it's probably best to spell that out.

[homerdin]

Updated documentation

[aaron.ballman]

This is missing a bunch of semantic tests that ensure the attribute appertains only to the expected subject, accepts no arguments, etc.

include/clang/Basic/AttrDocs.td

3475–3476

I'm not too keen on adding a new attribute that when used improperly will cause a miscompile without any diagnostics involved. How difficult would it be to add semantic checking to check functions with this attribute applied to it?

[homerdin]

I've added some additional test including semantic tests.

[homerdin]

include/clang/Basic/AttrDocs.td

3475–3476

I think the main purpose for having this attribute is to expose LLVM's WriteOnly attribute when we don't have access to the module. We can infer that a function is write-only in LLVM (https://reviews.llvm.org/D48387) when we have access to the function body. This attribute would allow us access to this information when we don't have access to the function body.

[hfinkel]

include/clang/Basic/AttrDocs.td

3475–3476

Do we have wording list this around the pure/const attributes (that we borrowed from GCC)? If we wish to say anything, and we probably should, the wording should be something like:

If a function with this attribute reads from memory, the behavior of the program is undefined.

Also, I'll add that this attribute, at the LLVM level, is an important part of optimizations we're working on for libm functions (when they set errno). We can do this "automatically" for actual libm functions, but we should also provide the user the ability to add these to functions of his or her choice (because we, to the extent possible, should allow a user to create functions that get optimized as well as the system-provided ones).

[aaron.ballman]

include/clang/Basic/AttrDocs.td

3475–3476

Do we have wording list this around the pure/const attributes (that we borrowed from GCC)?

Unfortunately, those are both undocumented attributes for us currently.

If we wish to say anything, and we probably should, the wording should be something like:

If a function with this attribute reads from memory, the behavior of the program is undefined.

I think this would clarity the documentation.

3475–3476

This attribute would allow us access to this information when we don't have access to the function body.

Understood, but I'm talking about the case where we see the function body because we're compiling it (rather than just using the declaration). Basically, I'm thinking of this case:

int i;
__attribute__((write_only_func)) int t0(void) {
  return i;
}

It seems like we'd want to tell the user "Hey, just so you know, this is bad." and ideally, drop the attribute so the user doesn't get a miscompile.

[homerdin]

Rebased. Updated wording in documentation

I added the functionality to apply this attribute to parameters in order to fully expose LLVM's WriteOnly attribute. Renaming the attribute to WriteOnly accordingly.

I would like to implement the semantic checking (for when we can see that the attribute is being misused) in a separate patch and include the logic to check for other attributes (pure). I'm looking into where they best place to implement this would be (any suggestions would be appreciated).

[aaron.ballman]

I'd like to see some C++ tests that check reference behavior (and perhaps more esoteric pointerish non-pointer types like member function pointers).

include/clang/Basic/AttrDocs.td

3465

an argument -> a parameter of pointer type

(question: what about parameters of reference type?)

3480

argument -> parameter

lib/Sema/SemaDeclAttr.cpp

1492

I think you want warn_attribute_pointer_or_reference_only if this accepts references as well as pointers.

1493

You can pass in AL directly these days.

6396–6400

No need to split these with a predicate, handleWriteOnlyAttrParameter() already does the right thing in both cases.

[homerdin]

Added additional tests and addressed the inline comments

[xbolva00]

Re-ping.

[aaron.ballman]

In D46313#1798318, @xbolva00 wrote:

Re-ping.

Thank you for re-pinging this, it fell off my radar entirely. I suspect the patch will need to be rebased as well.

include/clang/Basic/AttrDocs.td

3482

pointer -> pointer or reference

3485

pointer -> pointer or reference

lib/Sema/SemaDeclAttr.cpp

1485–1486

We don't usually early-return for invalid declarations when attaching attributes. I'd remove this.

1489–1490

if (const auto *PVD = dyn_cast<ParmVarDecl>(D)) {
  QualType T = PVD->getType();
  ...
}

test/CodeGen/attributes.c

120

I'd also like to see a test that this works fine on redeclarations. e.g.,

void tNN() __attribute__((write_only));
void tNN()  {} // The definition should still have the attribute

void tMM(int *b __attribute__((write_only)));
void tMM(int *b) {} // The definition should still have the attribute

include/clang/AST/Type.h

public:
   /// because the substitution of T=void, U=id into the former will
   /// not produce the latter.
   class ExtParameterInfo {
     enum {
       ABIMask         = 0x0F,
       IsConsumed      = 0x10,
       HasPassObjSize  = 0x20,
       IsNoEscape      = 0x40,
+      IsWriteOnly     = 0x80,
     };
     unsigned char Data = 0;
 
   public:
     ExtParameterInfo() = default;
 
     /// Return the ABI treatment of this parameter.
     ParameterABI getABI() const {
ExtParameterInfo withIsNoEscape(bool NoEscape) const {
       ExtParameterInfo Copy = *this;
       if (NoEscape)
         Copy.Data |= IsNoEscape;
       else
         Copy.Data &= ~IsNoEscape;
       return Copy;
     }
 
+    bool isWriteOnly() const {
+      return Data & IsWriteOnly;
+    }
+
+    ExtParameterInfo withIsWriteOnly(bool WriteOnly) const {
+      ExtParameterInfo Copy = *this;
+      if (WriteOnly)
+        Copy.Data |= IsWriteOnly;
+      else
+        Copy.Data &= ~IsWriteOnly;
+      return Copy;
+    }
+
     unsigned char getOpaqueValue() const { return Data; }
     static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
       ExtParameterInfo result;
       result.Data = data;
       return result;
     }
 
     friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {

include/clang/Basic/Attr.td

def Pcs : DeclOrTypeAttr {
   let Spellings = [GCC<"pcs">];
   let Args = [EnumArgument<"PCS", "PCSType",
                            ["aapcs", "aapcs-vfp"],
                            ["AAPCS", "AAPCS_VFP"]>];
 //  let Subjects = [Function, ObjCMethod];
   let Documentation = [PcsDocs];
 }
 
+def WriteOnly : Attr {
+  let Spellings = [Clang<"write_only">];
+  let Subjects = SubjectList<[Function, ParmVar], ErrorDiag>;
+  let Documentation = [WriteOnlyDocs];
+}
+
 def Pure : InheritableAttr {
   let Spellings = [GCC<"pure">];
   let Documentation = [Undocumented];
 }
 
 def Regparm : TypeAttr {
   let Spellings = [GCC<"regparm">];
   let Args = [UnsignedArgument<"NumParams">];

include/clang/Basic/AttrDocs.td

def ArtificialDocs : Documentation {
   let Content = [{
 The ``artificial`` attribute can be applied to an inline function. If such a
 function is inlined, the attribute indicates that debuggers should associate
 the resulting instructions with the call site, rather than with the
 corresponding line within the inlined callee.
   }];
 }
 
+def WriteOnlyDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``write_only`` attribute can be applied to a function or a parameter of
+pointer or reference type.
+
+When applied to a function, it indicates that the function may write to, but
+does not read from, memory.  A write-only function always writes the same value
+to the same memory location when called with the same set of arguments and
+global state.  
+
+When the ``write_only`` attribute is applied, function calls may be
+hoisted or eliminated when memory analysis determines it to be safe. When
+applied to a virtual function, the overridden functions are expected to
+adhere to be write-only functions.
+
+If a function with this attribute reads from memory, the behavior of the
+program is undefined.
+
+When applied to a parameter, it indicates that the function may write to but
+does not read through this pointer argument (even though it may read from
+memory that the pointer points to).
+
+If a function reads from a write-only pointer argument, the behavior is
+undefined.
+  }];
+}
+
 def ReinitializesDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``reinitializes`` attribute can be applied to a non-static, non-const C++
 member function to indicate that this member function reinitializes the entire
 object to a known state, independent of the previous state of the object.
 
 This attribute can be interpreted by static analyzers that warn about uses of an

lib/CodeGen/CGCall.cpp

if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
           getContext(), FuncAttrs, Fn->getType()->getAs<FunctionProtoType>());
       // Don't use [[noreturn]] or _Noreturn for a call to a virtual function.
       // These attributes are not inherited by overloads.
       const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn);
       if (Fn->isNoReturn() && !(AttrOnCallSite && MD && MD->isVirtual()))
         FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
     }
 
+    if (TargetDecl->hasAttr<WriteOnlyAttr>())
+      FuncAttrs.addAttribute(llvm::Attribute::WriteOnly);
+
     // 'const', 'pure' and 'noalias' attributed functions are also nounwind.
     if (TargetDecl->hasAttr<ConstAttr>()) {
       FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
     } else if (TargetDecl->hasAttr<PureAttr>()) {
       FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
     } else if (TargetDecl->hasAttr<NoAliasAttr>()) {
for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(),
     case ParameterABI::SwiftContext:
       Attrs.addAttribute(llvm::Attribute::SwiftSelf);
       break;
     }
 
     if (FI.getExtParameterInfo(ArgNo).isNoEscape())
       Attrs.addAttribute(llvm::Attribute::NoCapture);
 
+    if (FI.getExtParameterInfo(ArgNo).isWriteOnly())
+      Attrs.addAttribute(llvm::Attribute::WriteOnly);
+
     if (Attrs.hasAttributes()) {
       unsigned FirstIRArg, NumIRArgs;
       std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
       for (unsigned i = 0; i < NumIRArgs; i++)
         ArgAttrs[FirstIRArg + i] =
             llvm::AttributeSet::get(getLLVMContext(), Attrs);
     }
   }

lib/Sema/SemaDeclAttr.cpp

S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
         << AL << AL.getRange() << 0;
     return;
   }
 
   D->addAttr(::new (S.Context) NoEscapeAttr(
       AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
 }
 
+static void handleWriteOnlyAttrParameter(Sema &S, Decl *D,
+                                         const ParsedAttr &AL) {
+  if (D->isInvalidDecl())
+    return;
+
+  // write_only only applies to pointer types when applied to an argument.
+  if (isa<ParmVarDecl>(D)) {
+    QualType T = cast<ParmVarDecl>(D)->getType();
+    if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
+      S.Diag(AL.getLoc(), diag::warn_attribute_pointer_or_reference_only)
+          << AL << AL.getRange() << 0;
+      return;
+    }
+  }
+
+  D->addAttr(::new (S.Context) WriteOnlyAttr(
+      AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
+
+}
+
 static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   Expr *E = AL.getArgAsExpr(0),
        *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
   S.AddAssumeAlignedAttr(AL.getRange(), D, E, OE,
                          AL.getAttributeSpellingListIndex());
 }
 
 static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
case ParsedAttr::AT_ObjCIndependentClass:
     handleObjCIndependentClass(S, D, AL);
     break;
   case ParsedAttr::AT_Blocks:
     handleBlocksAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Sentinel:
     handleSentinelAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_WriteOnly:
+    handleWriteOnlyAttrParameter(S, D, AL);
+    break;
   case ParsedAttr::AT_Const:
     handleSimpleAttribute<ConstAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Pure:
     handleSimpleAttribute<PureAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_Cleanup:
     handleCleanupAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NoDebug:
     handleNoDebugAttr(S, D, AL);

lib/Sema/SemaType.cpp

case DeclaratorChunk::Function: {
             HasAnyInterestingExtParameterInfos = true;
           }
 
           if (Param->hasAttr<NoEscapeAttr>()) {
             ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(true);
             HasAnyInterestingExtParameterInfos = true;
           }
 
+          if (Param->hasAttr<WriteOnlyAttr>()) {
+            ExtParameterInfos[i] = ExtParameterInfos[i].withIsWriteOnly(true);
+            HasAnyInterestingExtParameterInfos = true;
+          }
+
           ParamTys.push_back(ParamTy);
         }
 
         if (HasAnyInterestingExtParameterInfos) {
           EPI.ExtParameterInfos = ExtParameterInfos.data();
           checkExtParameterInfos(S, ParamTys, EPI,
               [&](unsigned i) { return FTI.Params[i].Param->getLocation(); });
         }

test/CodeGen/attr-writeonly.cpp

+// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -disable-llvm-passes -Os -o - %s | FileCheck %s
+// // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -disable-llvm-passes -Os -o - %s | FileCheck %s
+// // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -disable-llvm-passes -Os -o - %s | FileCheck %/s
+
+class TestClass {
+  public:
+    void setI(int j) __attribute__((write_only));
+  private:
+    int I;
+};
+
+// CHECK-LABEL: define void @_Z5test1i(i32 %a)
+// CHECK: {
+// CHECK: call void @_ZN9TestClass4setIEi(%class.TestClass* %A, i32 %1)
+// CHECK: [[WO_CALL:#[0-9]+]]
+// CHECK: ret void
+
+void test1(int a) {
+  TestClass A;
+
+  A.setI(a);
+}
+
+// CHECK: declare void @_ZN9TestClass4setIEi(%class.TestClass*, i32) [[WO:#[0-9]+]]
+
+// CHECK: attributes [[WO]] = { optsize writeonly{{.*}} }
+// CHECK: attributes [[WO_CALL]] = { optsize writeonly }

test/CodeGen/attributes.c

 
 // CHECK: call void %{{[a-z0-9]+}}() [[NOCF_CHECK_CALL:#[0-9]+]]
 typedef void (*f_t)(void);
 void t24(f_t f1) {
   __attribute__((nocf_check)) f_t p = f1;
   (*p)();
 }
 
+// CHECK: define void @t25() [[WO_NUW:#[0-9]+]] {
+void t25() __attribute__((write_only));
+void t25() __attribute__((write_only)) {}
+
+
+// CHECK: define void @t26(i32* writeonly %b) [[NUW]] {
+void t26(int *b __attribute__((write_only)));
+void t26(int *b __attribute__((write_only))) {}
+
+//CHECK: declare void @t27(...) [[WO:#[0-9]+]]
+void t27() __attribute__((write_only));
+
+void t28();
+void t28() {t27();}
+
 // CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} }
 // CHECK: attributes [[NR]] = { noinline noreturn nounwind{{.*}} }
 // CHECK: attributes [[COLDDEF]] = { cold {{.*}}}
 // CHECK: attributes [[COLDDECL]] = { cold {{.*}}}
 // CHECK: attributes [[NOCF_CHECK_FUNC]] = { nocf_check {{.*}}}
+// CHECK: attributes [[WO_NUW]] = { noinline nounwind optnone writeonly{{.*}}}
+// CHECK: attributes [[WO]] = { writeonly{{.*}}}
 // CHECK: attributes [[COLDSITE]] = { cold {{.*}}}
 // CHECK: attributes [[NOCF_CHECK_CALL]] = { nocf_check }

test/CodeGen/function-attributes.c

 // CHECK: call i32 @_setjmp(i32* null)
 // CHECK: [[RT_CALL]]
 // CHECK: ret void
 int _setjmp(jmp_buf);
 void f20(void) {
   _setjmp(0);
 }
 
+// CHECK-LABEL: define void @f22()
+// CHECK: [[WO:#[0-9]+]]
+// CHECK: {
+// CHECK: call void @f21()
+// CHECK: [[WO_CALL:#[0-9]+]]
+// CHECK: ret void
+__attribute__ ((write_only)) void f21(void);
+__attribute__ ((write_only)) void f22(void) {
+  f21();
+}
+
 // CHECK: attributes [[NUW]] = { nounwind optsize{{.*}} }
 // CHECK: attributes [[AI]] = { alwaysinline nounwind optsize{{.*}} }
 // CHECK: attributes [[NUW_OS_RN]] = { nounwind optsize readnone{{.*}} }
 // CHECK: attributes [[SR]] = { nounwind optsize{{.*}} "stackrealign"{{.*}} }
 // CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} }
+// CHECK: attributes [[WO]] = { nounwind optsize writeonly{{.*}} }
 // CHECK: attributes [[NR]] = { noreturn optsize }
 // CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone }
 // CHECK: attributes [[RT_CALL]] = { optsize returns_twice }
+// CHECK: attributes [[WO_CALL]] = { optsize writeonly }

test/Misc/pragma-attribute-supported-attributes-list.test

 // RUN: clang-tblgen -gen-clang-test-pragma-attribute-supported-attributes -I%src_include_dir %src_include_dir/clang/Basic/Attr.td -o - | FileCheck %s
 
 // The number of supported attributes should never go down!
 
-// CHECK: #pragma clang attribute supports 74 attributes:
+// CHECK: #pragma clang attribute supports 75 attributes:
 // CHECK-NEXT: AMDGPUFlatWorkGroupSize (SubjectMatchRule_function)
 // CHECK-NEXT: AMDGPUNumSGPR (SubjectMatchRule_function)
 // CHECK-NEXT: AMDGPUNumVGPR (SubjectMatchRule_function)
 // CHECK-NEXT: AMDGPUWavesPerEU (SubjectMatchRule_function)
 // CHECK-NEXT: AVRSignal (SubjectMatchRule_function)
 // CHECK-NEXT: AbiTag (SubjectMatchRule_record_not_is_union, SubjectMatchRule_variable, SubjectMatchRule_function, SubjectMatchRule_namespace)
 // CHECK-NEXT: AlignValue (SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: AllocSize (SubjectMatchRule_function)

 // CHECK-NEXT: SwiftContext (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftErrorResult (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: SwiftIndirectResult (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: TLSModel (SubjectMatchRule_variable_is_thread_local)
 // CHECK-NEXT: Target (SubjectMatchRule_function)
 // CHECK-NEXT: TestTypestate (SubjectMatchRule_function_is_member)
 // CHECK-NEXT: TrivialABI (SubjectMatchRule_record)
 // CHECK-NEXT: WarnUnusedResult (SubjectMatchRule_objc_method, SubjectMatchRule_enum, SubjectMatchRule_record, SubjectMatchRule_hasType_functionType)
+// CHECK-NEXT: WriteOnly (SubjectMatchRule_function, SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: XRayInstrument (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: XRayLogArgs (SubjectMatchRule_function, SubjectMatchRule_objc_method)

test/Sema/attr-write-only.cpp

+// RUN: %clang_cc1 -std=c++11 %s -verify -fsyntax-only
+
+int a __attribute__((write_only)); // expected-error {{'write_only' attribute only applies to functions and parameters}}
+
+__attribute__((write_only)) void t0(void) {
+}
+
+void t1() __attribute__((write_only));
+
+void t2() __attribute__((write_only(2))); // expected-error {{'write_only' attribute takes no arguments}}
+
+typedef void (*t3)(void) __attribute__((write_only)); // expected-error {{'write_only' attribute only applies to functions and parameters}}
+
+void t4(int *b __attribute__((write_only)));
+
+void t5(int c __attribute__((write_only))); // expected-warning {{'write_only' attribute only applies to a pointer or reference }}
+
+typedef void (*t6)(int *d __attribute__((write_only)));
+
+int *e __attribute__((write_only)); // expected-error {{'write_only' attribute only applies to functions and parameters}}
+
+void t7(int *g __attribute__((write_only(3)))); // expected-error {{'write_only' attribute takes no arguments}}
+
+void t8(int& h __attribute__((write_only)));
+
+void (*func_ptr)(void) __attribute__((write_only)); // expected-error {{'write_only' attribute only applies to functions and parameters}}
+
+void (*func_ptr2)(double __attribute__((write_only))); // expected-warning {{'write_only' attribute only applies to a pointer or reference }}
+
+typedef int (*func_ptr3)(int, int);
+
+void t9(func_ptr3 __attribute__((write_only)));
+
+class TestClass {
+  public:
+    void setI(int j) __attribute__((write_only));
+  private:
+    int I;
+};
+
+typedef void(TestClass::*member_func_pntr)(int);
+
+void useSetter(int i, TestClass* pTestClass,
+              member_func_pntr mfp __attribute__((write_only))) { // expected-warning {{'write_only' attribute only applies to a pointer or reference }}
+  return (pTestClass->*mfp)(i);
+}