commit 8082cf9946c862ed9d72156b5ccc9a4fbfc38dbd
author Ulya Trafimovich <skvadrik@google.com> Thu Apr 07 12:47:13 2022 +0100
committer Ulya Trofimovich <skvadrik@google.com> Fri Apr 08 09:26:14 2022 +0000
tree 99bb765398004192d25c0c5249eb737e1fc9dd6e
parent 0a110f38530533e2bc09ec1995a207b4e99a4e9a

Add a check that we do not set intrinsic type `kNone`.

Bug: 228049006
Test: art/test.py --host
Change-Id: I9cb36954d6f3215d5c9c8aab9f23cae4c66fa6b7

runtime/art_method.h

diff --git a/runtime/art_method.h b/runtime/art_method.h
index d3005cd..9b11c26 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -27,6 +27,7 @@
 #include "base/bit_utils.h"
 #include "base/casts.h"
 #include "base/enums.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/runtime_debug.h"
 #include "dex/dex_file_structs.h"
@@ -115,6 +116,9 @@
   // concurrency so there is no need to guarantee atomicity. For example,
   // before the method is linked.
   void SetAccessFlags(uint32_t new_access_flags) REQUIRES_SHARED(Locks::mutator_lock_) {
+    // The following check ensures that we do not set `Intrinsics::kNone` (see b/228049006).
+    DCHECK_IMPLIES((new_access_flags & kAccIntrinsic) != 0,
+                   (new_access_flags & kAccIntrinsicBits) != 0);
     access_flags_.store(new_access_flags, std::memory_order_relaxed);
   }
 
@@ -882,7 +886,8 @@
 
   static inline bool IsValidIntrinsicUpdate(uint32_t modifier) {
     return (((modifier & kAccIntrinsic) == kAccIntrinsic) &&
-            (((modifier & ~(kAccIntrinsic | kAccIntrinsicBits)) == 0)));
+            ((modifier & ~(kAccIntrinsic | kAccIntrinsicBits)) == 0) &&
+            ((modifier & kAccIntrinsicBits) != 0));  // b/228049006: ensure intrinsic is not `kNone`
   }
 
   static inline bool OverlapsIntrinsicBits(uint32_t modifier) {
@@ -891,14 +896,14 @@
 
   // This setter guarantees atomicity.
   void AddAccessFlags(uint32_t flag) REQUIRES_SHARED(Locks::mutator_lock_) {
-    DCHECK(!IsIntrinsic() || !OverlapsIntrinsicBits(flag) || IsValidIntrinsicUpdate(flag));
+    DCHECK_IMPLIES(IsIntrinsic(), !OverlapsIntrinsicBits(flag) || IsValidIntrinsicUpdate(flag));
     // None of the readers rely ordering.
     access_flags_.fetch_or(flag, std::memory_order_relaxed);
   }
 
   // This setter guarantees atomicity.
   void ClearAccessFlags(uint32_t flag) REQUIRES_SHARED(Locks::mutator_lock_) {
-    DCHECK(!IsIntrinsic() || !OverlapsIntrinsicBits(flag) || IsValidIntrinsicUpdate(flag));
+    DCHECK_IMPLIES(IsIntrinsic(), !OverlapsIntrinsicBits(flag) || IsValidIntrinsicUpdate(flag));
     access_flags_.fetch_and(~flag, std::memory_order_relaxed);
   }