19: force: #507: 36: Failure after llvmorg-16-init-5673-ge07ead85a368: [Clang] Warn when trying to dereference void pointers in C

BUILD_URL: https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/507/

Failure after llvmorg-16-init-5673-ge07ead85a368: [Clang] Warn when trying to dereference void pointers in C:

Results changed to
-10
# build_abe binutils:
-9
# build_kernel_llvm:
-5
# build_abe qemu:
-2
# linux_n_obj:
36
# First few build errors in logs:
# 00:04:30 ./include/linux/fortify-string.h:159:10: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
# 00:04:30 ./include/linux/fortify-string.h:232:10: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
# 00:04:30 ./include/linux/fortify-string.h:470:9: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
# 00:04:30 ./include/linux/string.h:315:15: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
# 00:04:30 make[1]: *** [scripts/Makefile.build:117: scripts/mod/devicetable-offsets.s] Error 1
# 00:04:31 make: *** [Makefile:1204: prepare0] Error 2

from
-10
# build_abe binutils:
-9
# build_kernel_llvm:
-5
# build_abe qemu:
-2
# linux_n_obj:
21329
# linux build successful:
all

5 files changed, 451 insertions, 0 deletions

diff --git a/jenkins/jira-status.draft b/jenkins/jira-status.draft
new file mode 100644
index 0000000..1581c53
--- /dev/null
+++ b/jenkins/jira-status.draft
@@ -0,0 +1,4 @@
+[LLVM-646]
+#INTERESTING_COMMIT_STATUS#
+
+Details: https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/507/artifact/artifacts/jenkins/mail-body.txt/*view*/
diff --git a/jenkins/mail-body.draft b/jenkins/mail-body.draft
new file mode 100644
index 0000000..7d3db0c
--- /dev/null
+++ b/jenkins/mail-body.draft
@@ -0,0 +1,442 @@
+Failure after llvmorg-16-init-5673-ge07ead85a368: [Clang] Warn when trying to dereference void pointers in C:
+
+Results changed to
+-10
+# build_abe binutils:
+-9
+# build_kernel_llvm:
+-5
+# build_abe qemu:
+-2
+# linux_n_obj:
+36
+# First few build errors in logs:
+# 00:04:30 ./include/linux/fortify-string.h:159:10: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
+# 00:04:30 ./include/linux/fortify-string.h:232:10: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
+# 00:04:30 ./include/linux/fortify-string.h:470:9: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
+# 00:04:30 ./include/linux/string.h:315:15: error: ISO C does not allow indirection on operand of type 'void *' [-Werror,-Wvoid-ptr-dereference]
+# 00:04:30 make[1]: *** [scripts/Makefile.build:117: scripts/mod/devicetable-offsets.s] Error 1
+# 00:04:31 make: *** [Makefile:1204: prepare0] Error 2
+
+from
+-10
+# build_abe binutils:
+-9
+# build_kernel_llvm:
+-5
+# build_abe qemu:
+-2
+# linux_n_obj:
+21329
+# linux build successful:
+all
+
+THIS IS THE END OF INTERESTING STUFF.  BELOW ARE LINKS TO BUILDS, REPRODUCTION INSTRUCTIONS, AND THE RAW COMMIT.
+
+For latest status see comments in https://linaro.atlassian.net/browse/LLVM-646 .
+#INTERESTING_COMMIT_STATUS#
+
+Bad  build: https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/507/artifact/artifacts
+Good build: https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/506/artifact/artifacts
+
+Reproduce current build:
+<cut>
+mkdir -p investigate-llvm-e07ead85a368173a56e96a21d6841aa497ad80f8
+cd investigate-llvm-e07ead85a368173a56e96a21d6841aa497ad80f8
+
+# Fetch scripts
+git clone https://git.linaro.org/toolchain/jenkins-scripts
+
+# Fetch manifests for bad and good builds
+mkdir -p bad/artifacts good/artifacts
+curl -o bad/artifacts/manifest.sh https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/507/artifact/artifacts/manifest.sh --fail
+curl -o good/artifacts/manifest.sh https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/506/artifact/artifacts/manifest.sh --fail
+
+# Reproduce bad build
+(cd bad; ../jenkins-scripts/tcwg_kernel-build.sh ^^ true %%rr[top_artifacts] artifacts)
+# Reproduce good build
+(cd good; ../jenkins-scripts/tcwg_kernel-build.sh ^^ true %%rr[top_artifacts] artifacts)
+</cut>
+
+Full commit (up to 1000 lines):
+<cut>
+commit e07ead85a368173a56e96a21d6841aa497ad80f8
+Author: Jun Zhang <jun@junz.org>
+Date:   Sat Sep 24 22:18:04 2022 +0800
+
+    [Clang] Warn when trying to dereference void pointers in C
+    
+    Previously we only have an extension that warn void pointer deferencing
+    in C++, but for C we did nothing.
+    
+    C2x 6.5.3.2p4 says The unary * operator denotes indirection. If it points
+    to an object, the result is an lvalue designating the object. However, there
+    is no way to form an lvalue designating an object of an incomplete type as
+    6.3.2.1p1 says "an lvalue is an expression (with an object type other than
+    void)", so the behavior is undefined.
+    
+    Fixes https://github.com/llvm/llvm-project/issues/53631
+    
+    Signed-off-by: Jun Zhang <jun@junz.org>
+    
+    Differential Revision: https://reviews.llvm.org/D134461
+---
+ clang/docs/ReleaseNotes.rst                      |  2 ++
+ clang/include/clang/Basic/DiagnosticSemaKinds.td |  2 +-
+ clang/include/clang/Sema/Sema.h                  | 10 +++---
+ clang/lib/Parse/ParseExpr.cpp                    |  6 ++--
+ clang/lib/Sema/SemaExpr.cpp                      | 43 ++++++++++++------------
+ clang/test/Analysis/misc-ps.m                    |  2 +-
+ clang/test/C/drs/dr0xx.c                         |  3 +-
+ clang/test/C/drs/dr1xx.c                         | 24 +++++++++----
+ clang/test/Sema/asm.c                            |  5 +--
+ clang/test/Sema/builtins-arm.c                   |  7 ++--
+ clang/test/Sema/conditional-expr.c               | 13 ++++---
+ clang/test/Sema/deref.c                          |  3 +-
+ clang/test/Sema/expr-address-of.c                |  2 +-
+ clang/test/Sema/i-c-e.c                          |  3 +-
+ 14 files changed, 77 insertions(+), 48 deletions(-)
+
+diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
+index ed262823d004..a5e72fc917f3 100644
+--- a/clang/docs/ReleaseNotes.rst
++++ b/clang/docs/ReleaseNotes.rst
+@@ -210,6 +210,8 @@ Improvements to Clang's diagnostics
+   ``LL`` suffix.
+ - Clang now correctly diagnoses index that refers past the last possible element
+   of FAM-like arrays.
++- Clang now correctly diagnoses a warning when defercencing a void pointer in C mode.
++  This fixes `Issue 53631 <https://github.com/llvm/llvm-project/issues/53631>`_
+ 
+ Non-comprehensive list of changes in this release
+ -------------------------------------------------
+diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
+index 7647aa929b75..834b60a2744d 100644
+--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
++++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
+@@ -6919,7 +6919,7 @@ def err_typecheck_unary_expr : Error<
+ def err_typecheck_indirection_requires_pointer : Error<
+   "indirection requires pointer operand (%0 invalid)">;
+ def ext_typecheck_indirection_through_void_pointer : ExtWarn<
+-  "ISO C++ does not allow indirection on operand of type %0">,
++  "ISO %select{C|C++}0 does not allow indirection on operand of type %1">,
+   InGroup<DiagGroup<"void-ptr-dereference">>;
+ def warn_indirection_through_null : Warning<
+   "indirection of non-volatile null pointer will be deleted, not trap">,
+diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
+index 8628ed48481f..b6fd8174e1d8 100644
+--- a/clang/include/clang/Sema/Sema.h
++++ b/clang/include/clang/Sema/Sema.h
+@@ -5604,11 +5604,11 @@ public:
+ 
+   // Binary/Unary Operators.  'Tok' is the token for the operator.
+   ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
+-                                  Expr *InputExpr);
+-  ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
+-                          UnaryOperatorKind Opc, Expr *Input);
+-  ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
+-                          tok::TokenKind Op, Expr *Input);
++                                  Expr *InputExpr, bool IsAfterAmp = false);
++  ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc,
++                          Expr *Input, bool IsAfterAmp = false);
++  ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op,
++                          Expr *Input, bool IsAfterAmp = false);
+ 
+   bool isQualifiedMemberAccess(Expr *E);
+   QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
+diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
+index 77e8b9488a8c..9b3c39e7b43f 100644
+--- a/clang/lib/Parse/ParseExpr.cpp
++++ b/clang/lib/Parse/ParseExpr.cpp
+@@ -1360,7 +1360,8 @@ ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
+     // Special treatment because of member pointers
+     SourceLocation SavedLoc = ConsumeToken();
+     PreferredType.enterUnary(Actions, Tok.getLocation(), tok::amp, SavedLoc);
+-    Res = ParseCastExpression(AnyCastExpr, true);
++
++    Res = ParseCastExpression(AnyCastExpr, /*isAddressOfOperand=*/true);
+     if (!Res.isInvalid()) {
+       Expr *Arg = Res.get();
+       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg);
+@@ -1385,7 +1386,8 @@ ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
+     Res = ParseCastExpression(AnyCastExpr);
+     if (!Res.isInvalid()) {
+       Expr *Arg = Res.get();
+-      Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg);
++      Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg,
++                                 isAddressOfOperand);
+       if (Res.isInvalid())
+         Res = Actions.CreateRecoveryExpr(SavedLoc, Arg->getEndLoc(), Arg);
+     }
+diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
+index 0f25801c9a2d..acbf7d534d49 100644
+--- a/clang/lib/Sema/SemaExpr.cpp
++++ b/clang/lib/Sema/SemaExpr.cpp
+@@ -14493,7 +14493,8 @@ static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
+ 
+ /// CheckIndirectionOperand - Type check unary indirection (prefix '*').
+ static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
+-                                        SourceLocation OpLoc) {
++                                        SourceLocation OpLoc,
++                                        bool IsAfterAmp = false) {
+   if (Op->isTypeDependent())
+     return S.Context.DependentTy;
+ 
+@@ -14530,18 +14531,15 @@ static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
+     return QualType();
+   }
+ 
+-  // Note that per both C89 and C99, indirection is always legal, even if Result
+-  // is an incomplete type or void.  It would be possible to warn about
+-  // dereferencing a void pointer, but it's completely well-defined, and such a
+-  // warning is unlikely to catch any mistakes. In C++, indirection is not valid
+-  // for pointers to 'void' but is fine for any other pointer type:
+-  //
+-  // C++ [expr.unary.op]p1:
+-  //   [...] the expression to which [the unary * operator] is applied shall
+-  //   be a pointer to an object type, or a pointer to a function type
+-  if (S.getLangOpts().CPlusPlus && Result->isVoidType())
+-    S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
+-      << OpTy << Op->getSourceRange();
++  if (Result->isVoidType()) {
++    // C++ [expr.unary.op]p1:
++    //   [...] the expression to which [the unary * operator] is applied shall
++    //   be a pointer to an object type, or a pointer to a function type
++    LangOptions LO = S.getLangOpts();
++    if (LO.CPlusPlus || !(LO.C99 && IsAfterAmp))
++      S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
++          << LO.CPlusPlus << OpTy << Op->getSourceRange();
++  }
+ 
+   // Dereferences are usually l-values...
+   VK = VK_LValue;
+@@ -15530,8 +15528,8 @@ static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) {
+ }
+ 
+ ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
+-                                      UnaryOperatorKind Opc,
+-                                      Expr *InputExpr) {
++                                      UnaryOperatorKind Opc, Expr *InputExpr,
++                                      bool IsAfterAmp) {
+   ExprResult Input = InputExpr;
+   ExprValueKind VK = VK_PRValue;
+   ExprObjectKind OK = OK_Ordinary;
+@@ -15581,7 +15579,8 @@ ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
+   case UO_Deref: {
+     Input = DefaultFunctionArrayLvalueConversion(Input.get());
+     if (Input.isInvalid()) return ExprError();
+-    resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc);
++    resultType =
++        CheckIndirectionOperand(*this, Input.get(), VK, OpLoc, IsAfterAmp);
+     break;
+   }
+   case UO_Plus:
+@@ -15801,7 +15800,8 @@ bool Sema::isQualifiedMemberAccess(Expr *E) {
+ }
+ 
+ ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
+-                              UnaryOperatorKind Opc, Expr *Input) {
++                              UnaryOperatorKind Opc, Expr *Input,
++                              bool IsAfterAmp) {
+   // First things first: handle placeholders so that the
+   // overloaded-operator check considers the right type.
+   if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) {
+@@ -15840,13 +15840,14 @@ ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
+     return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
+   }
+ 
+-  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
++  return CreateBuiltinUnaryOp(OpLoc, Opc, Input, IsAfterAmp);
+ }
+ 
+ // Unary Operators.  'Tok' is the token for the operator.
+-ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
+-                              tok::TokenKind Op, Expr *Input) {
+-  return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
++ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op,
++                              Expr *Input, bool IsAfterAmp) {
++  return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input,
++                      IsAfterAmp);
+ }
+ 
+ /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
+diff --git a/clang/test/Analysis/misc-ps.m b/clang/test/Analysis/misc-ps.m
+index e9e56315eb26..4e3783dfc93a 100644
+--- a/clang/test/Analysis/misc-ps.m
++++ b/clang/test/Analysis/misc-ps.m
+@@ -133,7 +133,7 @@ void handle_sizeof_void(unsigned flag) {
+   void* q;
+   
+   if (!flag) {
+-    if (sizeof(*q) == 1)
++    if (sizeof(*q) == 1) // expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}
+       return;
+     // Infeasibe.
+     *p = 1; // no-warning
+diff --git a/clang/test/C/drs/dr0xx.c b/clang/test/C/drs/dr0xx.c
+index 183382406475..942e83bef886 100644
+--- a/clang/test/C/drs/dr0xx.c
++++ b/clang/test/C/drs/dr0xx.c
+@@ -160,7 +160,8 @@ void dr011(void) {
+  */
+ void dr012(void *p) {
+   /* The behavior changed between C89 and C99. */
+-  (void)&*p; /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}} */
++  (void)&*p; /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}}
++                c89only-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
+ }
+ 
+ /* WG14 DR013: yes
+diff --git a/clang/test/C/drs/dr1xx.c b/clang/test/C/drs/dr1xx.c
+index 70435b523765..400807ed5da8 100644
+--- a/clang/test/C/drs/dr1xx.c
++++ b/clang/test/C/drs/dr1xx.c
+@@ -137,11 +137,21 @@ void dr105(void) {
+  */
+ void dr106(void *p, int i) {
+   /* The behavior changed between C89 and C99. */
+-  (void)&*p; /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}} */
++  (void)&*p; /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}}
++                c89only-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
++
+   /* The behavior of all three of these is undefined. */
+-  (void)*p;
+-  (void)(i ? *p : *p);
+-  (void)(*p, *p); /* expected-warning {{left operand of comma operator has no effect}} */
++  (void)*p; /* expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}*/
++
++  (void)&(*p); /* c89only-warning {{ISO C forbids taking the address of an expression of type 'void'}}
++                  expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}*/
++
++  (void)(i ? *p : *p); /* expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}
++                          expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}*/
++
++  (void)(*p, *p); /* expected-warning {{left operand of comma operator has no effect}}
++                     expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}
++		     expected-warning {{ISO C does not allow indirection on operand of type 'void *'}}*/
+ }
+ 
+ /* WG14 DR108: yes
+@@ -178,10 +188,12 @@ void dr112(void *vp) {
+  * Return expressions in functions declared to return qualified void
+  */
+ volatile void dr113_v(volatile void *vvp) { /* expected-warning {{function cannot return qualified void type 'volatile void'}} */
+-  return *vvp; /* expected-warning {{void function 'dr113_v' should not return void expression}} */
++  return *vvp; /* expected-warning {{void function 'dr113_v' should not return void expression}}
++                  expected-warning{{ISO C does not allow indirection on operand of type 'volatile void *'}} */
+ }
+ const void dr113_c(const void *cvp) { /* expected-warning {{function cannot return qualified void type 'const void'}} */
+-  return *cvp; /* expected-warning {{void function 'dr113_c' should not return void expression}} */
++  return *cvp; /* expected-warning {{void function 'dr113_c' should not return void expression}}
++                  expected-warning{{ISO C does not allow indirection on operand of type 'const void *'}} */
+ }
+ 
+ /* WG14 DR114: yes
+diff --git a/clang/test/Sema/asm.c b/clang/test/Sema/asm.c
+index 3c7952f410c6..9f3fb3176b4e 100644
+--- a/clang/test/Sema/asm.c
++++ b/clang/test/Sema/asm.c
+@@ -50,8 +50,9 @@ void test3(void) {
+ // <rdar://problem/6156893>
+ void test4(const volatile void *addr)
+ {
+-    asm ("nop" : : "r"(*addr)); // expected-error {{invalid type 'const volatile void' in asm input for constraint 'r'}}
+-    asm ("nop" : : "m"(*addr));
++    asm ("nop" : : "r"(*addr)); /* expected-error {{invalid type 'const volatile void' in asm input for constraint 'r'}}
++                                   expected-warning {{ISO C does not allow indirection on operand of type 'const volatile void *'}} */
++    asm ("nop" : : "m"(*addr)); // expected-warning {{ISO C does not allow indirection on operand of type 'const volatile void *'}}
+ 
+     asm ("nop" : : "r"(test4(addr))); // expected-error {{invalid type 'void' in asm input for constraint 'r'}}
+     asm ("nop" : : "m"(test4(addr))); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
+diff --git a/clang/test/Sema/builtins-arm.c b/clang/test/Sema/builtins-arm.c
+index 7c731204da09..0a59fd555bee 100644
+--- a/clang/test/Sema/builtins-arm.c
++++ b/clang/test/Sema/builtins-arm.c
+@@ -18,7 +18,8 @@ void __clear_cache(void*, void*);
+ void test1(void) {
+   __builtin_va_list ptr;
+   ptr.__ap = "x";
+-  *(ptr.__ap) = '0'; // expected-error {{incomplete type 'void' is not assignable}}
++  *(ptr.__ap) = '0'; /* expected-error {{incomplete type 'void' is not assignable}}
++                        expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
+ }
+ #else
+ // va_list on ARM apcs-gnu is void*.
+@@ -30,7 +31,9 @@ void test1(void) {
+ 
+ void test2(void) {
+   __builtin_va_list ptr = "x";
+-  *ptr = '0'; // expected-error {{incomplete type 'void' is not assignable}}
++  *ptr = '0'; /* expected-error {{incomplete type 'void' is not assignable}}
++                 expected-warning {{ISO C does not allow indirection on operand of type '__builtin_va_list'}} */
++
+ }
+ #endif
+ 
+diff --git a/clang/test/Sema/conditional-expr.c b/clang/test/Sema/conditional-expr.c
+index ff4fd73f4c5c..81997459c1f2 100644
+--- a/clang/test/Sema/conditional-expr.c
++++ b/clang/test/Sema/conditional-expr.c
+@@ -2,11 +2,16 @@
+ void foo(void) {
+   *(0 ? (double *)0 : (void *)0) = 0;
+   // FIXME: GCC doesn't consider the following two statements to be errors.
+-  *(0 ? (double *)0 : (void *)(int *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}}
+-  *(0 ? (double *)0 : (void *)(double *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}}
+-  *(0 ? (double *)0 : (int *)(void *)0) = 0; // expected-error {{incomplete type 'void' is not assignable}} expected-warning {{pointer type mismatch ('double *' and 'int *')}}
++  *(0 ? (double *)0 : (void *)(int *)0) = 0; /* expected-error {{incomplete type 'void' is not assignable}}
++                                                expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
++  *(0 ? (double *)0 : (void *)(double *)0) = 0; /* expected-error {{incomplete type 'void' is not assignable}}
++                                                   expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
++  *(0 ? (double *)0 : (int *)(void *)0) = 0; /* expected-error {{incomplete type 'void' is not assignable}}
++                                                expected-warning {{pointer type mismatch ('double *' and 'int *')}}
++                                                expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
+   *(0 ? (double *)0 : (double *)(void *)0) = 0;
+-  *((void *) 0) = 0; // expected-error {{incomplete type 'void' is not assignable}}
++  *((void *) 0) = 0; /* expected-error {{incomplete type 'void' is not assignable}}
++                        expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
+   double *dp;
+   int *ip;
+   void *vp;
+diff --git a/clang/test/Sema/deref.c b/clang/test/Sema/deref.c
+index 845b28645a48..45c921967bcc 100644
+--- a/clang/test/Sema/deref.c
++++ b/clang/test/Sema/deref.c
+@@ -18,7 +18,8 @@ void foo2 (void)
+ void foo3 (void)
+ {
+  void* x = 0;
+- void* y = &*x; /* expected-warning{{address of an expression of type 'void'}} */
++ void* y = &*x; /* expected-warning{{address of an expression of type 'void'}}
++                   expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
+ }
+ 
+ extern const void cv1;
+diff --git a/clang/test/Sema/expr-address-of.c b/clang/test/Sema/expr-address-of.c
+index 8881038b3241..057b7843ce6b 100644
+--- a/clang/test/Sema/expr-address-of.c
++++ b/clang/test/Sema/expr-address-of.c
+@@ -105,7 +105,7 @@ char* f7(void) {
+   int* dummy2 = &(t2.a); // expected-error {{address of bit-field requested}}
+   int* dummy3 = &(t2.b); // expected-error {{address of bit-field requested}}
+ 
+-  void* t3 = &(*(void*)0);
++  void* t3 = &*(void*)0;
+ }
+ 
+ void f8(void) {
+diff --git a/clang/test/Sema/i-c-e.c b/clang/test/Sema/i-c-e.c
+index b348b4f3c43e..31dad5836549 100644
+--- a/clang/test/Sema/i-c-e.c
++++ b/clang/test/Sema/i-c-e.c
+@@ -3,7 +3,8 @@
+ #include <stdint.h>
+ #include <limits.h>
+ 
+-int a(void) {int p; *(1 ? &p : (void*)(0 && (a(),1))) = 10;} // expected-error {{incomplete type 'void' is not assignable}}
++int a(void) {int p; *(1 ? &p : (void*)(0 && (a(),1))) = 10;} /* expected-error {{incomplete type 'void' is not assignable}}
++                                                                expected-warning {{ISO C does not allow indirection on operand of type 'void *'}} */
+ 
+ // rdar://6091492 - ?: with __builtin_constant_p as the operand is an i-c-e.
+ int expr;
+</cut>
diff --git a/jenkins/mail-recipients.draft b/jenkins/mail-recipients.draft
new file mode 100644
index 0000000..6bdf19b
--- /dev/null
+++ b/jenkins/mail-recipients.draft
@@ -0,0 +1 @@
+Jun Zhang <jun@junz.org>,cc:llvm@lists.linux.dev
diff --git a/jenkins/mail-subject.draft b/jenkins/mail-subject.draft
new file mode 100644
index 0000000..79de6f9
--- /dev/null
+++ b/jenkins/mail-subject.draft
@@ -0,0 +1 @@
+[TCWG CI] Failure after llvmorg-16-init-5673-ge07ead85a368: [Clang] Warn when trying to dereference void pointers in C
diff --git a/jenkins/notify.sh b/jenkins/notify.sh
new file mode 100755
index 0000000..066cf30
--- /dev/null
+++ b/jenkins/notify.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+/home/tcwg-buildslave/workspace/tcwg_kernel_0/jenkins-scripts/round-robin-notify.sh --artifacts "artifacts/jenkins" --BUILD_URL "https://ci.linaro.org/job/tcwg_kernel-llvm-build-llvm-master-aarch64-mainline-allyesconfig/507/" --ci_project "tcwg_kernel" --ci_config "llvm-master-aarch64-mainline-allyesconfig" --current_project "llvm" --first_bad "e07ead85a368173a56e96a21d6841aa497ad80f8" --last_good "5351878ba1963a84600df3a9e907b458b0529851" --summary "artifacts/mail/jira-body.txt"