runtime/oat/jni_stub_hash_map.cc - platform/art - Git at Google

 /*
  * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "jni_stub_hash_map.h"

 #include "arch/arm64/jni_frame_arm64.h"
 #include "arch/instruction_set.h"
 #include "arch/riscv64/jni_frame_riscv64.h"
 #include "arch/x86_64/jni_frame_x86_64.h"
 #include "base/macros.h"
 #include "dex/modifiers.h"

 namespace art HIDDEN {

 static char TranslateArgToJniShorty(char ch) {
   // Byte, char, int, short, boolean are treated the same(e.g., Wx registers for arm64) when
   // generating JNI stub, so their JNI shorty characters are same.
   //                                       ABCDEFGHIJKLMNOPQRSTUVWXYZ
   static constexpr char kTranslations[] = ".PPD.F..PJ.L......P......P";
   DCHECK_GE(ch, 'A');
   DCHECK_LE(ch, 'Z');
   DCHECK_NE(kTranslations[ch - 'A'], '.');
   return kTranslations[ch - 'A'];
 }

 static char TranslateReturnTypeToJniShorty(char ch, InstructionSet isa = InstructionSet::kNone) {
   // For all archs, reference type has a different JNI shorty character than others as it needs to
   // be decoded in stub.
   // For arm64, small return types need sign-/zero-extended.
   // For x86_64, small return types need sign-/zero-extended, and RAX needs to be preserved and
   // restored when thread state changes.
   // Other archs keeps untranslated for simplicity.
   // TODO: support riscv64 with an optimized version.
   //                                             ABCDEFGHIJKLMNOPQRSTUVWXYZ
   static constexpr char kArm64Translations[] =  ".BCP.P..PP.L......S..P...Z";
   static constexpr char kX86_64Translations[] = ".BCP.P..RR.L......S..P...Z";
   static constexpr char kOtherTranslations[] =  ".BCD.F..IJ.L......S..V...Z";
   DCHECK_GE(ch, 'A');
   DCHECK_LE(ch, 'Z');
   switch (isa) {
     case InstructionSet::kArm64:
       DCHECK_NE(kArm64Translations[ch - 'A'], '.');
       return kArm64Translations[ch - 'A'];
     case InstructionSet::kX86_64:
       DCHECK_NE(kX86_64Translations[ch - 'A'], '.');
       return kX86_64Translations[ch - 'A'];
     default:
       DCHECK_NE(kOtherTranslations[ch - 'A'], '.');
       return kOtherTranslations[ch - 'A'];
   }
 }

 static constexpr size_t GetMaxIntLikeRegisterArgs(InstructionSet isa) {
   switch (isa) {
     case InstructionSet::kArm64:
       return arm64::kMaxIntLikeRegisterArguments;
     case InstructionSet::kX86_64:
       return x86_64::kMaxIntLikeRegisterArguments;
     default:
       LOG(FATAL) << "Unrecognized isa: " << isa << " for " << __FUNCTION__;
       UNREACHABLE();
   }
 }

 static constexpr size_t GetMaxFloatOrDoubleRegisterArgs(InstructionSet isa) {
   switch (isa) {
     case InstructionSet::kArm64:
       return arm64::kMaxFloatOrDoubleRegisterArguments;
     case InstructionSet::kX86_64:
       return x86_64::kMaxFloatOrDoubleRegisterArguments;
     default:
       LOG(FATAL) << "Unrecognized isa: " << isa << " for " << __FUNCTION__;
       UNREACHABLE();
   }
 }

 static size_t StackOffset(char ch) {
   if (ch == 'J' || ch == 'D') {
     return 8;
   } else {
     return 4;
   }
 }

 static bool IsFloatOrDoubleArg(char ch) {
   return ch == 'F' || ch == 'D';
 }

 static bool IsIntegralArg(char ch) {
   return ch == 'B' || ch == 'C' || ch == 'I' || ch == 'J' || ch == 'S' || ch == 'Z';
 }

 static bool IsReferenceArg(char ch) {
   return ch == 'L';
 }

 template<InstructionSet kIsa>
 size_t JniStubKeyOptimizedHash(const JniStubKey& key) {
   bool is_static = key.Flags() & kAccStatic;
   std::string_view shorty = key.Shorty();
   size_t result = key.Flags();
   result ^= TranslateReturnTypeToJniShorty(shorty[0], kIsa);
   constexpr size_t kMaxFloatOrDoubleRegisterArgs = GetMaxFloatOrDoubleRegisterArgs(kIsa);
   constexpr size_t kMaxIntLikeRegisterArgs = GetMaxIntLikeRegisterArgs(kIsa);
   size_t float_or_double_args = 0;
   // ArtMethod* and 'Object* this' for non-static method.
   // ArtMethod* for static method.
   size_t int_like_args = is_static ? 1 : 2;
   size_t stack_offset = 0;
   for (char c : shorty.substr(1u)) {
     bool stack_offset_matters = false;
     stack_offset += StackOffset(c);
     if (IsFloatOrDoubleArg(c)) {
       ++float_or_double_args;
       if (float_or_double_args > kMaxFloatOrDoubleRegisterArgs) {
         // Stack offset matters if we run out of float-like (float, double) argument registers
         // because the subsequent float-like args should be passed on the stack.
         stack_offset_matters = true;
       } else {
         // Floating-point register arguments are not touched when generating JNI stub, so could be
         // ignored when calculating hash value.
         continue;
       }
     } else {
       ++int_like_args;
       if (int_like_args > kMaxIntLikeRegisterArgs || IsReferenceArg(c)) {
         // Stack offset matters if we run out of integer-like (pointer, object, long, int, short,
         // bool, etc) argument registers because the subsequent integer-like args should be passed
         // on the stack. It also matters if current arg is reference type because it needs to be
         // spilled as raw data even if it's in a register.
         stack_offset_matters = true;
       } else if (!is_static) {
         // For non-static method, two managed arguments 'ArtMethod*' and 'Object* this' correspond
         // to two native arguments 'JNIEnv*' and 'jobject'. So trailing integral (long, int, short,
         // bool, etc) arguments will remain in the same registers, which do not need any generated
         // code.
         // But for static method, we have only one leading managed argument 'ArtMethod*' but two
         // native arguments 'JNIEnv*' and 'jclass'. So trailing integral arguments are always
         // shuffled around and affect the generated code.
         continue;
       }
     }
     // int_like_args is needed for reference type because it will determine from which register
     // we take the value to construct jobject.
     if (IsReferenceArg(c)) {
       result = result * 31u * int_like_args ^ TranslateArgToJniShorty(c);
     } else {
       result = result * 31u ^ TranslateArgToJniShorty(c);
     }
     if (stack_offset_matters) {
       result += stack_offset;
     }
   }
   return result;
 }

 size_t JniStubKeyGenericHash(const JniStubKey& key) {
   std::string_view shorty = key.Shorty();
   size_t result = key.Flags();
   result ^= TranslateReturnTypeToJniShorty(shorty[0]);
   for (char c : shorty.substr(1u)) {
     result = result * 31u ^ TranslateArgToJniShorty(c);
   }
   return result;
 }

 JniStubKeyHash::JniStubKeyHash(InstructionSet isa) {
   switch (isa) {
     case InstructionSet::kArm:
     case InstructionSet::kThumb2:
     case InstructionSet::kRiscv64:
     case InstructionSet::kX86:
       hash_func_ = JniStubKeyGenericHash;
       break;
     case InstructionSet::kArm64:
       hash_func_ = JniStubKeyOptimizedHash<InstructionSet::kArm64>;
       break;
     case InstructionSet::kX86_64:
       hash_func_ = JniStubKeyOptimizedHash<InstructionSet::kX86_64>;
       break;
     case InstructionSet::kNone:
       LOG(FATAL) << "No instruction set given for " << __FUNCTION__;
       UNREACHABLE();
   }
 }

 template<InstructionSet kIsa>
 bool JniStubKeyOptimizedEquals(const JniStubKey& lhs, const JniStubKey& rhs) {
   if (lhs.Flags() != rhs.Flags()) {
     return false;
   }
   std::string_view shorty_lhs = lhs.Shorty();
   std::string_view shorty_rhs = rhs.Shorty();
   if (TranslateReturnTypeToJniShorty(shorty_lhs[0], kIsa) !=
       TranslateReturnTypeToJniShorty(shorty_rhs[0], kIsa)) {
     return false;
   }
   bool is_static = lhs.Flags() & kAccStatic;
   constexpr size_t kMaxFloatOrDoubleRegisterArgs = GetMaxFloatOrDoubleRegisterArgs(kIsa);
   constexpr size_t kMaxIntLikeRegisterArgs = GetMaxIntLikeRegisterArgs(kIsa);
   size_t float_or_double_args_lhs = 0;
   size_t float_or_double_args_rhs = 0;
   size_t int_like_args_lhs = is_static ? 1 : 2;
   size_t int_like_args_rhs = is_static ? 1 : 2;
   size_t stack_offset_lhs = 0;
   size_t stack_offset_rhs = 0;
   size_t i = 1;
   size_t j = 1;
   while (i < shorty_lhs.length() && j < shorty_rhs.length()) {
     bool should_skip = false;
     bool stack_offset_matters = false;
     char ch_lhs = shorty_lhs[i];
     char ch_rhs = shorty_rhs[j];

     if (IsFloatOrDoubleArg(ch_lhs) &&
         float_or_double_args_lhs < kMaxFloatOrDoubleRegisterArgs) {
       // Skip float-like register arguments.
       ++i;
       ++float_or_double_args_lhs;
       stack_offset_lhs += StackOffset(ch_lhs);
       should_skip = true;
     } else if (IsIntegralArg(ch_lhs) &&
         int_like_args_lhs < kMaxIntLikeRegisterArgs) {
       if (!is_static) {
         // Skip integral register arguments for non-static method.
         ++i;
         ++int_like_args_lhs;
         stack_offset_lhs += StackOffset(ch_lhs);
         should_skip = true;
       }
     } else {
       stack_offset_matters = true;
     }

     if (IsFloatOrDoubleArg(ch_rhs) &&
         float_or_double_args_rhs < kMaxFloatOrDoubleRegisterArgs) {
       // Skip float-like register arguments.
       ++j;
       ++float_or_double_args_rhs;
       stack_offset_rhs += StackOffset(ch_rhs);
       should_skip = true;
     } else if (IsIntegralArg(ch_rhs) &&
         int_like_args_rhs < kMaxIntLikeRegisterArgs) {
       if (!is_static) {
         // Skip integral register arguments for non-static method.
         ++j;
         ++int_like_args_rhs;
         stack_offset_rhs += StackOffset(ch_rhs);
         should_skip = true;
       }
     } else {
       stack_offset_matters = true;
     }

     if (should_skip) {
       continue;
     }
     if (TranslateArgToJniShorty(ch_lhs) != TranslateArgToJniShorty(ch_rhs)) {
       return false;
     }
     if (stack_offset_matters && stack_offset_lhs != stack_offset_rhs) {
       return false;
     }
     // int_like_args needs to be compared for reference type because it will determine from
     // which register we take the value to construct jobject.
     if (IsReferenceArg(ch_lhs) && int_like_args_lhs != int_like_args_rhs) {
       return false;
     }
     // Passed character comparison.
     ++i;
     ++j;
     stack_offset_lhs += StackOffset(ch_lhs);
     stack_offset_rhs += StackOffset(ch_rhs);
     DCHECK_EQ(IsFloatOrDoubleArg(ch_lhs), IsFloatOrDoubleArg(ch_rhs));
     if (IsFloatOrDoubleArg(ch_lhs)) {
       ++float_or_double_args_lhs;
       ++float_or_double_args_rhs;
     } else {
       ++int_like_args_lhs;
       ++int_like_args_rhs;
     }
   }
   auto remaining_shorty =
       i < shorty_lhs.length() ? shorty_lhs.substr(i) : shorty_rhs.substr(j);
   size_t float_or_double_args =
       i < shorty_lhs.length() ? float_or_double_args_lhs : float_or_double_args_rhs;
   size_t int_like_args = i < shorty_lhs.length() ? int_like_args_lhs : int_like_args_rhs;
   for (char c : remaining_shorty) {
     if (IsFloatOrDoubleArg(c) && float_or_double_args < kMaxFloatOrDoubleRegisterArgs) {
       ++float_or_double_args;
       continue;
     }
     if (!is_static && IsIntegralArg(c) && int_like_args < kMaxIntLikeRegisterArgs) {
       ++int_like_args;
       continue;
     }
     return false;
   }
   return true;
 }

 bool JniStubKeyGenericEquals(const JniStubKey& lhs, const JniStubKey& rhs) {
   if (lhs.Flags() != rhs.Flags()) {
     return false;
   }
   std::string_view shorty_lhs = lhs.Shorty();
   std::string_view shorty_rhs = rhs.Shorty();
   if (TranslateReturnTypeToJniShorty(shorty_lhs[0]) !=
       TranslateReturnTypeToJniShorty(shorty_rhs[0])) {
     return false;
   }
   if (shorty_lhs.length() != shorty_rhs.length()) {
     return false;
   }
   for (size_t i = 1; i < shorty_lhs.length(); ++i) {
     if (TranslateArgToJniShorty(shorty_lhs[i]) != TranslateArgToJniShorty(shorty_rhs[i])) {
       return false;
     }
   }
   return true;
 }

 JniStubKeyEquals::JniStubKeyEquals(InstructionSet isa) {
   switch (isa) {
     case InstructionSet::kArm:
     case InstructionSet::kThumb2:
     case InstructionSet::kRiscv64:
     case InstructionSet::kX86:
       equals_func_ = JniStubKeyGenericEquals;
       break;
     case InstructionSet::kArm64:
       equals_func_ = JniStubKeyOptimizedEquals<InstructionSet::kArm64>;
       break;
     case InstructionSet::kX86_64:
       equals_func_ = JniStubKeyOptimizedEquals<InstructionSet::kX86_64>;
       break;
     case InstructionSet::kNone:
       LOG(FATAL) << "No instruction set given for " << __FUNCTION__;
       UNREACHABLE();
   }
 }

 }  // namespace art
	/*
	* Copyright (C) 2024 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "jni_stub_hash_map.h"

	#include "arch/arm64/jni_frame_arm64.h"
	#include "arch/instruction_set.h"
	#include "arch/riscv64/jni_frame_riscv64.h"
	#include "arch/x86_64/jni_frame_x86_64.h"
	#include "base/macros.h"
	#include "dex/modifiers.h"

	namespace art HIDDEN {

	static char TranslateArgToJniShorty(char ch) {
	// Byte, char, int, short, boolean are treated the same(e.g., Wx registers for arm64) when
	// generating JNI stub, so their JNI shorty characters are same.
	// ABCDEFGHIJKLMNOPQRSTUVWXYZ
	static constexpr char kTranslations[] = ".PPD.F..PJ.L......P......P";
	DCHECK_GE(ch, 'A');
	DCHECK_LE(ch, 'Z');
	DCHECK_NE(kTranslations[ch - 'A'], '.');
	return kTranslations[ch - 'A'];
	}

	static char TranslateReturnTypeToJniShorty(char ch, InstructionSet isa = InstructionSet::kNone) {
	// For all archs, reference type has a different JNI shorty character than others as it needs to
	// be decoded in stub.
	// For arm64, small return types need sign-/zero-extended.
	// For x86_64, small return types need sign-/zero-extended, and RAX needs to be preserved and
	// restored when thread state changes.
	// Other archs keeps untranslated for simplicity.
	// TODO: support riscv64 with an optimized version.
	// ABCDEFGHIJKLMNOPQRSTUVWXYZ
	static constexpr char kArm64Translations[] = ".BCP.P..PP.L......S..P...Z";
	static constexpr char kX86_64Translations[] = ".BCP.P..RR.L......S..P...Z";
	static constexpr char kOtherTranslations[] = ".BCD.F..IJ.L......S..V...Z";
	DCHECK_GE(ch, 'A');
	DCHECK_LE(ch, 'Z');
	switch (isa) {
	case InstructionSet::kArm64:
	DCHECK_NE(kArm64Translations[ch - 'A'], '.');
	return kArm64Translations[ch - 'A'];
	case InstructionSet::kX86_64:
	DCHECK_NE(kX86_64Translations[ch - 'A'], '.');
	return kX86_64Translations[ch - 'A'];
	default:
	DCHECK_NE(kOtherTranslations[ch - 'A'], '.');
	return kOtherTranslations[ch - 'A'];
	}
	}

	static constexpr size_t GetMaxIntLikeRegisterArgs(InstructionSet isa) {
	switch (isa) {
	case InstructionSet::kArm64:
	return arm64::kMaxIntLikeRegisterArguments;
	case InstructionSet::kX86_64:
	return x86_64::kMaxIntLikeRegisterArguments;
	default:
	LOG(FATAL) << "Unrecognized isa: " << isa << " for " << __FUNCTION__;
	UNREACHABLE();
	}
	}

	static constexpr size_t GetMaxFloatOrDoubleRegisterArgs(InstructionSet isa) {
	switch (isa) {
	case InstructionSet::kArm64:
	return arm64::kMaxFloatOrDoubleRegisterArguments;
	case InstructionSet::kX86_64:
	return x86_64::kMaxFloatOrDoubleRegisterArguments;
	default:
	LOG(FATAL) << "Unrecognized isa: " << isa << " for " << __FUNCTION__;
	UNREACHABLE();
	}
	}

	static size_t StackOffset(char ch) {
	if (ch == 'J' \|\| ch == 'D') {
	return 8;
	} else {
	return 4;
	}
	}

	static bool IsFloatOrDoubleArg(char ch) {
	return ch == 'F' \|\| ch == 'D';
	}

	static bool IsIntegralArg(char ch) {
	return ch == 'B' \|\| ch == 'C' \|\| ch == 'I' \|\| ch == 'J' \|\| ch == 'S' \|\| ch == 'Z';
	}

	static bool IsReferenceArg(char ch) {
	return ch == 'L';
	}

	template<InstructionSet kIsa>
	size_t JniStubKeyOptimizedHash(const JniStubKey& key) {
	bool is_static = key.Flags() & kAccStatic;
	std::string_view shorty = key.Shorty();
	size_t result = key.Flags();
	result ^= TranslateReturnTypeToJniShorty(shorty[0], kIsa);
	constexpr size_t kMaxFloatOrDoubleRegisterArgs = GetMaxFloatOrDoubleRegisterArgs(kIsa);
	constexpr size_t kMaxIntLikeRegisterArgs = GetMaxIntLikeRegisterArgs(kIsa);
	size_t float_or_double_args = 0;
	// ArtMethod* and 'Object* this' for non-static method.
	// ArtMethod* for static method.
	size_t int_like_args = is_static ? 1 : 2;
	size_t stack_offset = 0;
	for (char c : shorty.substr(1u)) {
	bool stack_offset_matters = false;
	stack_offset += StackOffset(c);
	if (IsFloatOrDoubleArg(c)) {
	++float_or_double_args;
	if (float_or_double_args > kMaxFloatOrDoubleRegisterArgs) {
	// Stack offset matters if we run out of float-like (float, double) argument registers
	// because the subsequent float-like args should be passed on the stack.
	stack_offset_matters = true;
	} else {
	// Floating-point register arguments are not touched when generating JNI stub, so could be
	// ignored when calculating hash value.
	continue;
	}
	} else {
	++int_like_args;
	if (int_like_args > kMaxIntLikeRegisterArgs \|\| IsReferenceArg(c)) {
	// Stack offset matters if we run out of integer-like (pointer, object, long, int, short,
	// bool, etc) argument registers because the subsequent integer-like args should be passed
	// on the stack. It also matters if current arg is reference type because it needs to be
	// spilled as raw data even if it's in a register.
	stack_offset_matters = true;
	} else if (!is_static) {
	// For non-static method, two managed arguments 'ArtMethod' and 'Object this' correspond
	// to two native arguments 'JNIEnv*' and 'jobject'. So trailing integral (long, int, short,
	// bool, etc) arguments will remain in the same registers, which do not need any generated
	// code.
	// But for static method, we have only one leading managed argument 'ArtMethod*' but two
	// native arguments 'JNIEnv*' and 'jclass'. So trailing integral arguments are always
	// shuffled around and affect the generated code.
	continue;
	}
	}
	// int_like_args is needed for reference type because it will determine from which register
	// we take the value to construct jobject.
	if (IsReferenceArg(c)) {
	result = result * 31u * int_like_args ^ TranslateArgToJniShorty(c);
	} else {
	result = result * 31u ^ TranslateArgToJniShorty(c);
	}
	if (stack_offset_matters) {
	result += stack_offset;
	}
	}
	return result;
	}

	size_t JniStubKeyGenericHash(const JniStubKey& key) {
	std::string_view shorty = key.Shorty();
	size_t result = key.Flags();
	result ^= TranslateReturnTypeToJniShorty(shorty[0]);
	for (char c : shorty.substr(1u)) {
	result = result * 31u ^ TranslateArgToJniShorty(c);
	}
	return result;
	}

	JniStubKeyHash::JniStubKeyHash(InstructionSet isa) {
	switch (isa) {
	case InstructionSet::kArm:
	case InstructionSet::kThumb2:
	case InstructionSet::kRiscv64:
	case InstructionSet::kX86:
	hash_func_ = JniStubKeyGenericHash;
	break;
	case InstructionSet::kArm64:
	hash_func_ = JniStubKeyOptimizedHash<InstructionSet::kArm64>;
	break;
	case InstructionSet::kX86_64:
	hash_func_ = JniStubKeyOptimizedHash<InstructionSet::kX86_64>;
	break;
	case InstructionSet::kNone:
	LOG(FATAL) << "No instruction set given for " << __FUNCTION__;
	UNREACHABLE();
	}
	}

	template<InstructionSet kIsa>
	bool JniStubKeyOptimizedEquals(const JniStubKey& lhs, const JniStubKey& rhs) {
	if (lhs.Flags() != rhs.Flags()) {
	return false;
	}
	std::string_view shorty_lhs = lhs.Shorty();
	std::string_view shorty_rhs = rhs.Shorty();
	if (TranslateReturnTypeToJniShorty(shorty_lhs[0], kIsa) !=
	TranslateReturnTypeToJniShorty(shorty_rhs[0], kIsa)) {
	return false;
	}
	bool is_static = lhs.Flags() & kAccStatic;
	constexpr size_t kMaxFloatOrDoubleRegisterArgs = GetMaxFloatOrDoubleRegisterArgs(kIsa);
	constexpr size_t kMaxIntLikeRegisterArgs = GetMaxIntLikeRegisterArgs(kIsa);
	size_t float_or_double_args_lhs = 0;
	size_t float_or_double_args_rhs = 0;
	size_t int_like_args_lhs = is_static ? 1 : 2;
	size_t int_like_args_rhs = is_static ? 1 : 2;
	size_t stack_offset_lhs = 0;
	size_t stack_offset_rhs = 0;
	size_t i = 1;
	size_t j = 1;
	while (i < shorty_lhs.length() && j < shorty_rhs.length()) {
	bool should_skip = false;
	bool stack_offset_matters = false;
	char ch_lhs = shorty_lhs[i];
	char ch_rhs = shorty_rhs[j];

	if (IsFloatOrDoubleArg(ch_lhs) &&
	float_or_double_args_lhs < kMaxFloatOrDoubleRegisterArgs) {
	// Skip float-like register arguments.
	++i;
	++float_or_double_args_lhs;
	stack_offset_lhs += StackOffset(ch_lhs);
	should_skip = true;
	} else if (IsIntegralArg(ch_lhs) &&
	int_like_args_lhs < kMaxIntLikeRegisterArgs) {
	if (!is_static) {
	// Skip integral register arguments for non-static method.
	++i;
	++int_like_args_lhs;
	stack_offset_lhs += StackOffset(ch_lhs);
	should_skip = true;
	}
	} else {
	stack_offset_matters = true;
	}

	if (IsFloatOrDoubleArg(ch_rhs) &&
	float_or_double_args_rhs < kMaxFloatOrDoubleRegisterArgs) {
	// Skip float-like register arguments.
	++j;
	++float_or_double_args_rhs;
	stack_offset_rhs += StackOffset(ch_rhs);
	should_skip = true;
	} else if (IsIntegralArg(ch_rhs) &&
	int_like_args_rhs < kMaxIntLikeRegisterArgs) {
	if (!is_static) {
	// Skip integral register arguments for non-static method.
	++j;
	++int_like_args_rhs;
	stack_offset_rhs += StackOffset(ch_rhs);
	should_skip = true;
	}
	} else {
	stack_offset_matters = true;
	}

	if (should_skip) {
	continue;
	}
	if (TranslateArgToJniShorty(ch_lhs) != TranslateArgToJniShorty(ch_rhs)) {
	return false;
	}
	if (stack_offset_matters && stack_offset_lhs != stack_offset_rhs) {
	return false;
	}
	// int_like_args needs to be compared for reference type because it will determine from
	// which register we take the value to construct jobject.
	if (IsReferenceArg(ch_lhs) && int_like_args_lhs != int_like_args_rhs) {
	return false;
	}
	// Passed character comparison.
	++i;
	++j;
	stack_offset_lhs += StackOffset(ch_lhs);
	stack_offset_rhs += StackOffset(ch_rhs);
	DCHECK_EQ(IsFloatOrDoubleArg(ch_lhs), IsFloatOrDoubleArg(ch_rhs));
	if (IsFloatOrDoubleArg(ch_lhs)) {
	++float_or_double_args_lhs;
	++float_or_double_args_rhs;
	} else {
	++int_like_args_lhs;
	++int_like_args_rhs;
	}
	}
	auto remaining_shorty =
	i < shorty_lhs.length() ? shorty_lhs.substr(i) : shorty_rhs.substr(j);
	size_t float_or_double_args =
	i < shorty_lhs.length() ? float_or_double_args_lhs : float_or_double_args_rhs;
	size_t int_like_args = i < shorty_lhs.length() ? int_like_args_lhs : int_like_args_rhs;
	for (char c : remaining_shorty) {
	if (IsFloatOrDoubleArg(c) && float_or_double_args < kMaxFloatOrDoubleRegisterArgs) {
	++float_or_double_args;
	continue;
	}
	if (!is_static && IsIntegralArg(c) && int_like_args < kMaxIntLikeRegisterArgs) {
	++int_like_args;
	continue;
	}
	return false;
	}
	return true;
	}

	bool JniStubKeyGenericEquals(const JniStubKey& lhs, const JniStubKey& rhs) {
	if (lhs.Flags() != rhs.Flags()) {
	return false;
	}
	std::string_view shorty_lhs = lhs.Shorty();
	std::string_view shorty_rhs = rhs.Shorty();
	if (TranslateReturnTypeToJniShorty(shorty_lhs[0]) !=
	TranslateReturnTypeToJniShorty(shorty_rhs[0])) {
	return false;
	}
	if (shorty_lhs.length() != shorty_rhs.length()) {
	return false;
	}
	for (size_t i = 1; i < shorty_lhs.length(); ++i) {
	if (TranslateArgToJniShorty(shorty_lhs[i]) != TranslateArgToJniShorty(shorty_rhs[i])) {
	return false;
	}
	}
	return true;
	}

	JniStubKeyEquals::JniStubKeyEquals(InstructionSet isa) {
	switch (isa) {
	case InstructionSet::kArm:
	case InstructionSet::kThumb2:
	case InstructionSet::kRiscv64:
	case InstructionSet::kX86:
	equals_func_ = JniStubKeyGenericEquals;
	break;
	case InstructionSet::kArm64:
	equals_func_ = JniStubKeyOptimizedEquals<InstructionSet::kArm64>;
	break;
	case InstructionSet::kX86_64:
	equals_func_ = JniStubKeyOptimizedEquals<InstructionSet::kX86_64>;
	break;
	case InstructionSet::kNone:
	LOG(FATAL) << "No instruction set given for " << __FUNCTION__;
	UNREACHABLE();
	}
	}

	} // namespace art