cleanup: change Set/GetIntrinsic in ArtMethod to use Intrinsics

Test: art/test/testrunner/testrunner.py --host --64 --optimizing -b
Change-Id: I253a6bfe6bba7e02e527722c4632cb60938fe1c6

11 files changed, 21 insertions, 21 deletions

diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index 45322e7e27..90df4521e8 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -1346,8 +1346,7 @@ bool HInliner::TryDevirtualize(HInvoke* invoke_instruction,
   // Don't devirtualize to an intrinsic invalid after the builder phase. The ArtMethod might be an
   // intrinsic even when the HInvoke isn't e.g. java.lang.CharSequence.isEmpty (not an intrinsic)
   // can get devirtualized into java.lang.String.isEmpty (which is an intrinsic).
-  if (method->IsIntrinsic() &&
-      !IsValidIntrinsicAfterBuilder(static_cast<Intrinsics>(method->GetIntrinsic()))) {
+  if (method->IsIntrinsic() && !IsValidIntrinsicAfterBuilder(method->GetIntrinsic())) {
     return false;
   }
 
@@ -1598,7 +1597,7 @@ bool HInliner::TryBuildAndInline(HInvoke* invoke_instruction,
   // another chance before we try to inline it.
   if (invoke_instruction->GetResolvedMethod() != method &&
       method->IsIntrinsic() &&
-      IsValidIntrinsicAfterBuilder(static_cast<Intrinsics>(method->GetIntrinsic()))) {
+      IsValidIntrinsicAfterBuilder(method->GetIntrinsic())) {
     MaybeRecordStat(stats_, MethodCompilationStat::kIntrinsicRecognized);
     // For simplicity, always create a new instruction to replace the existing
     // invoke.
diff --git a/compiler/optimizing/instruction_builder.cc b/compiler/optimizing/instruction_builder.cc
index 356322e85b..f3676bbc02 100644
--- a/compiler/optimizing/instruction_builder.cc
+++ b/compiler/optimizing/instruction_builder.cc
@@ -1944,7 +1944,7 @@ bool HInstructionBuilder::BuildSimpleIntrinsic(ArtMethod* method,
                                                uint32_t dex_pc,
                                                const InstructionOperands& operands,
                                                const char* shorty) {
-  Intrinsics intrinsic = static_cast<Intrinsics>(method->GetIntrinsic());
+  Intrinsics intrinsic = method->GetIntrinsic();
   DCHECK_NE(intrinsic, Intrinsics::kNone);
   constexpr DataType::Type kInt32 = DataType::Type::kInt32;
   constexpr DataType::Type kInt64 = DataType::Type::kInt64;
diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc
index a45d250307..588f4d7ce2 100644
--- a/compiler/optimizing/nodes.cc
+++ b/compiler/optimizing/nodes.cc
@@ -3450,7 +3450,7 @@ static inline IntrinsicExceptions GetExceptionsIntrinsic(Intrinsics i) {
 
 void HInvoke::SetResolvedMethod(ArtMethod* method, bool enable_intrinsic_opt) {
   if (method != nullptr && method->IsIntrinsic() && enable_intrinsic_opt) {
-    Intrinsics intrinsic = static_cast<Intrinsics>(method->GetIntrinsic());
+    Intrinsics intrinsic = method->GetIntrinsic();
     SetIntrinsic(intrinsic,
                  NeedsEnvironmentIntrinsic(intrinsic),
                  GetSideEffectsIntrinsic(intrinsic),
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index cc1b5ed6df..d4bed097ec 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -38,6 +38,7 @@
 #include "gc/accounting/card_table-inl.h"
 #include "hidden_api.h"
 #include "interpreter/interpreter.h"
+#include "intrinsics_enum.h"
 #include "jit/jit.h"
 #include "jit/jit_code_cache.h"
 #include "jit/profiling_info.h"
@@ -717,14 +718,15 @@ const void* ArtMethod::GetOatMethodQuickCode(PointerSize pointer_size) {
   return nullptr;
 }
 
-void ArtMethod::SetIntrinsic(uint32_t intrinsic) {
+void ArtMethod::SetIntrinsic(Intrinsics intrinsic) {
   // Currently we only do intrinsics for static/final methods or methods of final
   // classes. We don't set kHasSingleImplementation for those methods.
   DCHECK(IsStatic() || IsFinal() || GetDeclaringClass()->IsFinal()) <<
       "Potential conflict with kAccSingleImplementation";
   static const int kAccFlagsShift = CTZ(kAccIntrinsicBits);
-  DCHECK_LE(intrinsic, kAccIntrinsicBits >> kAccFlagsShift);
-  uint32_t intrinsic_bits = intrinsic << kAccFlagsShift;
+  uint32_t intrinsic_u32 = enum_cast<uint32_t>(intrinsic);
+  DCHECK_LE(intrinsic_u32, kAccIntrinsicBits >> kAccFlagsShift);
+  uint32_t intrinsic_bits = intrinsic_u32 << kAccFlagsShift;
   uint32_t new_value = (GetAccessFlags() & ~kAccIntrinsicBits) | kAccIntrinsic | intrinsic_bits;
   if (kIsDebugBuild) {
     uint32_t java_flags = (GetAccessFlags() & kAccJavaFlagsMask);
diff --git a/runtime/art_method.h b/runtime/art_method.h
index 597bc64d39..30dc09f67f 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -35,6 +35,7 @@
 #include "dex/primitive.h"
 #include "interpreter/mterp/nterp.h"
 #include "gc_root.h"
+#include "intrinsics_enum.h"
 #include "obj_ptr.h"
 #include "offsets.h"
 #include "read_barrier_option.h"
@@ -246,16 +247,16 @@ class EXPORT ArtMethod final {
     return (access_flags & kAccIntrinsic) != 0;
   }
 
-  ALWAYS_INLINE void SetIntrinsic(uint32_t intrinsic) REQUIRES_SHARED(Locks::mutator_lock_);
+  ALWAYS_INLINE void SetIntrinsic(Intrinsics intrinsic) REQUIRES_SHARED(Locks::mutator_lock_);
 
-  uint32_t GetIntrinsic() const {
+  Intrinsics GetIntrinsic() const {
     static const int kAccFlagsShift = CTZ(kAccIntrinsicBits);
     static_assert(IsPowerOfTwo((kAccIntrinsicBits >> kAccFlagsShift) + 1),
                   "kAccIntrinsicBits are not continuous");
     static_assert((kAccIntrinsic & kAccIntrinsicBits) == 0,
                   "kAccIntrinsic overlaps kAccIntrinsicBits");
     DCHECK(IsIntrinsic());
-    return (GetAccessFlags() & kAccIntrinsicBits) >> kAccFlagsShift;
+    return static_cast<Intrinsics>((GetAccessFlags() & kAccIntrinsicBits) >> kAccFlagsShift);
   }
 
   void SetNotIntrinsic() REQUIRES_SHARED(Locks::mutator_lock_);
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 692b0c40ed..822774e73c 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -2416,7 +2416,7 @@ extern "C" uint64_t artInvokePolymorphic(mirror::Object* raw_receiver, Thread* s
   // Call DoInvokePolymorphic with |is_range| = true, as shadow frame has argument registers in
   // consecutive order.
   RangeInstructionOperands operands(first_arg + 1, num_vregs - 1);
-  Intrinsics intrinsic = static_cast<Intrinsics>(resolved_method->GetIntrinsic());
+  Intrinsics intrinsic = resolved_method->GetIntrinsic();
   JValue result;
   bool success = false;
   if (resolved_method->GetDeclaringClass() == GetClassRoot<mirror::MethodHandle>(linker)) {
diff --git a/runtime/hidden_api.h b/runtime/hidden_api.h
index 4b97b0d552..851ed70784 100644
--- a/runtime/hidden_api.h
+++ b/runtime/hidden_api.h
@@ -286,7 +286,7 @@ ALWAYS_INLINE inline uint32_t GetRuntimeFlags(ArtField* field)
 ALWAYS_INLINE inline uint32_t GetRuntimeFlags(ArtMethod* method)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   if (UNLIKELY(method->IsIntrinsic())) {
-    switch (static_cast<Intrinsics>(method->GetIntrinsic())) {
+    switch (method->GetIntrinsic()) {
       case Intrinsics::kSystemArrayCopyChar:
       case Intrinsics::kSystemArrayCopyByte:
       case Intrinsics::kSystemArrayCopyInt:
diff --git a/runtime/interpreter/interpreter_common.cc b/runtime/interpreter/interpreter_common.cc
index f11c62bc71..1fcace6d3b 100644
--- a/runtime/interpreter/interpreter_common.cc
+++ b/runtime/interpreter/interpreter_common.cc
@@ -580,7 +580,7 @@ bool DoInvokePolymorphic(Thread* self,
   DCHECK(invoke_method->IsIntrinsic());
 
   // Dispatch based on intrinsic identifier associated with method.
-  switch (static_cast<art::Intrinsics>(invoke_method->GetIntrinsic())) {
+  switch (invoke_method->GetIntrinsic()) {
 #define CASE_SIGNATURE_POLYMORPHIC_INTRINSIC(Name, ...) \
     case Intrinsics::k##Name:                           \
       return Do ## Name(self, shadow_frame, inst, inst_data, result);
diff --git a/runtime/method_handles.cc b/runtime/method_handles.cc
index f2ac3c89ca..c4e4d206a4 100644
--- a/runtime/method_handles.cc
+++ b/runtime/method_handles.cc
@@ -721,9 +721,8 @@ bool DoVarHandleInvokeTranslation(Thread* self,
 
   // Determine the accessor kind to dispatch
   ArtMethod* target_method = method_handle->GetTargetMethod();
-  int intrinsic_index = target_method->GetIntrinsic();
   mirror::VarHandle::AccessMode access_mode =
-      mirror::VarHandle::GetAccessModeByIntrinsic(static_cast<Intrinsics>(intrinsic_index));
+      mirror::VarHandle::GetAccessModeByIntrinsic(target_method->GetIntrinsic());
   Handle<mirror::MethodType> vh_type =
       hs.NewHandle(vh->GetMethodTypeForAccessMode(self, access_mode));
   Handle<mirror::MethodType> mh_invoke_type = hs.NewHandle(
diff --git a/runtime/runtime_intrinsics.cc b/runtime/runtime_intrinsics.cc
index 40e6ace958..278854d9e7 100644
--- a/runtime/runtime_intrinsics.cc
+++ b/runtime/runtime_intrinsics.cc
@@ -63,10 +63,10 @@ bool InitializeIntrinsic(Thread* self,
 
   CHECK_EQ(method->GetInvokeType(), invoke_type);
   if (method->IsIntrinsic()) {
-    CHECK_EQ(method->GetIntrinsic(), static_cast<uint32_t>(intrinsic));
+    CHECK_EQ(method->GetIntrinsic(), intrinsic);
     return true;
   } else {
-    method->SetIntrinsic(static_cast<uint32_t>(intrinsic));
+    method->SetIntrinsic(intrinsic);
     return false;
   }
 }
@@ -83,7 +83,7 @@ bool IsIntrinsicInitialized(Thread* self,
 
   CHECK_EQ(method->GetInvokeType(), invoke_type);
   if (method->IsIntrinsic()) {
-    CHECK_EQ(method->GetIntrinsic(), static_cast<uint32_t>(intrinsic));
+    CHECK_EQ(method->GetIntrinsic(), intrinsic);
     return true;
   } else {
     return false;
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 32fb4aa098..dcbe1382e0 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -4214,8 +4214,7 @@ class ReferenceMapVisitor : public StackVisitor {
     if (m->IsNative()) {
       // TODO: Spill the `this` reference in the AOT-compiled String.charAt()
       // slow-path for throwing SIOOBE, so that we can remove this carve-out.
-      if (UNLIKELY(m->IsIntrinsic()) &&
-          m->GetIntrinsic() == enum_cast<uint32_t>(Intrinsics::kStringCharAt)) {
+      if (UNLIKELY(m->IsIntrinsic()) && m->GetIntrinsic() == Intrinsics::kStringCharAt) {
         // The String.charAt() method is AOT-compiled with an intrinsic implementation
         // instead of a JNI stub. It has a slow path that constructs a runtime frame
         // for throwing SIOOBE and in that path we do not get the `this` pointer