Remove need for intrinsic recognizer to be a pass.

Instead just recognize the intrinsic when creating an invoke
instruction.

Also remove some old code related to compiler driver sharpening.

Test: test.py
Change-Id: Iecb668f30e95034970fcf57160ca12092c9c610d

24 files changed, 179 insertions, 342 deletions

diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index 1be96fbd50..7f94a298eb 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -1296,9 +1296,7 @@ bool HInliner::TryInlineAndReplace(HInvoke* invoke_instruction,
 
   // If invoke_instruction is devirtualized to a different method, give intrinsics
   // another chance before we try to inline it.
-  bool wrong_invoke_type = false;
-  if (invoke_instruction->GetResolvedMethod() != method &&
-      IntrinsicsRecognizer::Recognize(invoke_instruction, method, &wrong_invoke_type)) {
+  if (invoke_instruction->GetResolvedMethod() != method && method->IsIntrinsic()) {
     MaybeRecordStat(stats_, MethodCompilationStat::kIntrinsicRecognized);
     if (invoke_instruction->IsInvokeInterface()) {
       // We don't intrinsify an invoke-interface directly.
@@ -1311,6 +1309,7 @@ bool HInliner::TryInlineAndReplace(HInvoke* invoke_instruction,
           invoke_instruction->GetDexMethodIndex(),  // Use interface method's dex method index.
           method,
           method->GetMethodIndex());
+      DCHECK_NE(new_invoke->GetIntrinsic(), Intrinsics::kNone);
       HInputsRef inputs = invoke_instruction->GetInputs();
       for (size_t index = 0; index != inputs.size(); ++index) {
         new_invoke->SetArgumentAt(index, inputs[index]);
@@ -1320,14 +1319,11 @@ bool HInliner::TryInlineAndReplace(HInvoke* invoke_instruction,
       if (invoke_instruction->GetType() == DataType::Type::kReference) {
         new_invoke->SetReferenceTypeInfo(invoke_instruction->GetReferenceTypeInfo());
       }
-      // Run intrinsic recognizer again to set new_invoke's intrinsic.
-      IntrinsicsRecognizer::Recognize(new_invoke, method, &wrong_invoke_type);
-      DCHECK_NE(new_invoke->GetIntrinsic(), Intrinsics::kNone);
       return_replacement = new_invoke;
       // invoke_instruction is replaced with new_invoke.
       should_remove_invoke_instruction = true;
     } else {
-      // invoke_instruction is intrinsified and stays.
+      invoke_instruction->SetResolvedMethod(method);
     }
   } else if (!TryBuildAndInline(invoke_instruction, method, receiver_type, &return_replacement)) {
     if (invoke_instruction->IsInvokeInterface()) {
@@ -2023,10 +2019,8 @@ void HInliner::RunOptimizations(HGraph* callee_graph,
   HDeadCodeElimination dce(callee_graph, inline_stats_, "dead_code_elimination$inliner");
   HConstantFolding fold(callee_graph, "constant_folding$inliner");
   InstructionSimplifier simplify(callee_graph, codegen_, inline_stats_);
-  IntrinsicsRecognizer intrinsics(callee_graph, inline_stats_);
 
   HOptimization* optimizations[] = {
-    &intrinsics,
     &simplify,
     &fold,
     &dce,
diff --git a/compiler/optimizing/intrinsics.cc b/compiler/optimizing/intrinsics.cc
index 21efe11f31..619cd8ed41 100644
--- a/compiler/optimizing/intrinsics.cc
+++ b/compiler/optimizing/intrinsics.cc
@@ -32,179 +32,6 @@
 
 namespace art {
 
-// Check that intrinsic enum values fit within space set aside in ArtMethod modifier flags.
-#define CHECK_INTRINSICS_ENUM_VALUES(Name, IsStatic, NeedsEnvironmentOrCache, SideEffects, Exceptions, ...) \
-  static_assert( \
-      static_cast<uint32_t>(Intrinsics::k ## Name) <= (kAccIntrinsicBits >> CTZ(kAccIntrinsicBits)), \
-      "Instrinsics enumeration space overflow.");
-#include "intrinsics_list.h"
-  INTRINSICS_LIST(CHECK_INTRINSICS_ENUM_VALUES)
-#undef INTRINSICS_LIST
-#undef CHECK_INTRINSICS_ENUM_VALUES
-
-// Function that returns whether an intrinsic is static/direct or virtual.
-static inline InvokeType GetIntrinsicInvokeType(Intrinsics i) {
-  switch (i) {
-    case Intrinsics::kNone:
-      return kInterface;  // Non-sensical for intrinsic.
-#define OPTIMIZING_INTRINSICS(Name, IsStatic, NeedsEnvironmentOrCache, SideEffects, Exceptions, ...) \
-    case Intrinsics::k ## Name: \
-      return IsStatic;
-#include "intrinsics_list.h"
-      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
-#undef INTRINSICS_LIST
-#undef OPTIMIZING_INTRINSICS
-  }
-  return kInterface;
-}
-
-// Function that returns whether an intrinsic needs an environment or not.
-static inline IntrinsicNeedsEnvironmentOrCache NeedsEnvironmentOrCache(Intrinsics i) {
-  switch (i) {
-    case Intrinsics::kNone:
-      return kNeedsEnvironmentOrCache;  // Non-sensical for intrinsic.
-#define OPTIMIZING_INTRINSICS(Name, IsStatic, NeedsEnvironmentOrCache, SideEffects, Exceptions, ...) \
-    case Intrinsics::k ## Name: \
-      return NeedsEnvironmentOrCache;
-#include "intrinsics_list.h"
-      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
-#undef INTRINSICS_LIST
-#undef OPTIMIZING_INTRINSICS
-  }
-  return kNeedsEnvironmentOrCache;
-}
-
-// Function that returns whether an intrinsic has side effects.
-static inline IntrinsicSideEffects GetSideEffects(Intrinsics i) {
-  switch (i) {
-    case Intrinsics::kNone:
-      return kAllSideEffects;
-#define OPTIMIZING_INTRINSICS(Name, IsStatic, NeedsEnvironmentOrCache, SideEffects, Exceptions, ...) \
-    case Intrinsics::k ## Name: \
-      return SideEffects;
-#include "intrinsics_list.h"
-      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
-#undef INTRINSICS_LIST
-#undef OPTIMIZING_INTRINSICS
-  }
-  return kAllSideEffects;
-}
-
-// Function that returns whether an intrinsic can throw exceptions.
-static inline IntrinsicExceptions GetExceptions(Intrinsics i) {
-  switch (i) {
-    case Intrinsics::kNone:
-      return kCanThrow;
-#define OPTIMIZING_INTRINSICS(Name, IsStatic, NeedsEnvironmentOrCache, SideEffects, Exceptions, ...) \
-    case Intrinsics::k ## Name: \
-      return Exceptions;
-#include "intrinsics_list.h"
-      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
-#undef INTRINSICS_LIST
-#undef OPTIMIZING_INTRINSICS
-  }
-  return kCanThrow;
-}
-
-static bool CheckInvokeType(Intrinsics intrinsic, HInvoke* invoke)
-    REQUIRES_SHARED(Locks::mutator_lock_) {
-  // Whenever the intrinsic is marked as static, report an error if we find an InvokeVirtual.
-  //
-  // Whenever the intrinsic is marked as direct and we find an InvokeVirtual, a devirtualization
-  // failure occured. We might be in a situation where we have inlined a method that calls an
-  // intrinsic, but that method is in a different dex file on which we do not have a
-  // verified_method that would have helped the compiler driver sharpen the call. In that case,
-  // make sure that the intrinsic is actually for some final method (or in a final class), as
-  // otherwise the intrinsics setup is broken.
-  //
-  // For the last direction, we have intrinsics for virtual functions that will perform a check
-  // inline. If the precise type is known, however, the instruction will be sharpened to an
-  // InvokeStaticOrDirect.
-  InvokeType intrinsic_type = GetIntrinsicInvokeType(intrinsic);
-  InvokeType invoke_type = invoke->GetInvokeType();
-
-  switch (intrinsic_type) {
-    case kStatic:
-      return (invoke_type == kStatic);
-
-    case kDirect:
-      if (invoke_type == kDirect) {
-        return true;
-      }
-      if (invoke_type == kVirtual) {
-        ArtMethod* art_method = invoke->GetResolvedMethod();
-        return (art_method->IsFinal() || art_method->GetDeclaringClass()->IsFinal());
-      }
-      return false;
-
-    case kVirtual:
-      // Call might be devirtualized.
-      return (invoke_type == kVirtual || invoke_type == kDirect || invoke_type == kInterface);
-
-    case kSuper:
-    case kInterface:
-    case kPolymorphic:
-    case kCustom:
-      return false;
-  }
-  LOG(FATAL) << "Unknown intrinsic invoke type: " << intrinsic_type;
-  UNREACHABLE();
-}
-
-bool IntrinsicsRecognizer::Recognize(HInvoke* invoke,
-                                     ArtMethod* art_method,
-                                     /*out*/ bool* wrong_invoke_type) {
-  if (art_method == nullptr) {
-    art_method = invoke->GetResolvedMethod();
-  }
-  *wrong_invoke_type = false;
-  if (art_method == nullptr || !art_method->IsIntrinsic()) {
-    return false;
-  }
-
-  // TODO: b/65872996 The intent is that polymorphic signature methods should
-  // be compiler intrinsics. At present, they are only interpreter intrinsics.
-  if (art_method->IsPolymorphicSignature()) {
-    return false;
-  }
-
-  Intrinsics intrinsic = static_cast<Intrinsics>(art_method->GetIntrinsic());
-  if (CheckInvokeType(intrinsic, invoke) == false) {
-    *wrong_invoke_type = true;
-    return false;
-  }
-
-  invoke->SetIntrinsic(intrinsic,
-                       NeedsEnvironmentOrCache(intrinsic),
-                       GetSideEffects(intrinsic),
-                       GetExceptions(intrinsic));
-  return true;
-}
-
-bool IntrinsicsRecognizer::Run() {
-  bool didRecognize = false;
-  ScopedObjectAccess soa(Thread::Current());
-  for (HBasicBlock* block : graph_->GetReversePostOrder()) {
-    for (HInstructionIterator inst_it(block->GetInstructions()); !inst_it.Done();
-         inst_it.Advance()) {
-      HInstruction* inst = inst_it.Current();
-      if (inst->IsInvoke()) {
-        bool wrong_invoke_type = false;
-        if (Recognize(inst->AsInvoke(), /* art_method */ nullptr, &wrong_invoke_type)) {
-          didRecognize = true;
-          MaybeRecordStat(stats_, MethodCompilationStat::kIntrinsicRecognized);
-        } else if (wrong_invoke_type) {
-          LOG(WARNING)
-              << "Found an intrinsic with unexpected invoke type: "
-              << inst->AsInvoke()->GetResolvedMethod()->PrettyMethod() << " "
-              << inst->DebugName();
-        }
-      }
-    }
-  }
-  return didRecognize;
-}
-
 std::ostream& operator<<(std::ostream& os, const Intrinsics& intrinsic) {
   switch (intrinsic) {
     case Intrinsics::kNone:
diff --git a/compiler/optimizing/intrinsics.h b/compiler/optimizing/intrinsics.h
index 2d93f234be..59012faea7 100644
--- a/compiler/optimizing/intrinsics.h
+++ b/compiler/optimizing/intrinsics.h
@@ -34,28 +34,6 @@ static constexpr uint64_t kPositiveInfinityDouble = UINT64_C(0x7ff0000000000000)
 static constexpr uint32_t kNanFloat = 0x7fc00000U;
 static constexpr uint64_t kNanDouble = 0x7ff8000000000000;
 
-// Recognize intrinsics from HInvoke nodes.
-class IntrinsicsRecognizer : public HOptimization {
- public:
-  IntrinsicsRecognizer(HGraph* graph,
-                       OptimizingCompilerStats* stats,
-                       const char* name = kIntrinsicsRecognizerPassName)
-      : HOptimization(graph, name, stats) {}
-
-  bool Run() override;
-
-  // Static helper that recognizes intrinsic call. Returns true on success.
-  // If it fails due to invoke type mismatch, wrong_invoke_type is set.
-  // Useful to recognize intrinsics on individual calls outside this full pass.
-  static bool Recognize(HInvoke* invoke, ArtMethod* method, /*out*/ bool* wrong_invoke_type)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
-  static constexpr const char* kIntrinsicsRecognizerPassName = "intrinsics_recognition";
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(IntrinsicsRecognizer);
-};
-
 class IntrinsicVisitor : public ValueObject {
  public:
   virtual ~IntrinsicVisitor() {}
diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc
index 79a7e2c858..aad06b91b6 100644
--- a/compiler/optimizing/nodes.cc
+++ b/compiler/optimizing/nodes.cc
@@ -3180,4 +3180,77 @@ std::ostream& operator<<(std::ostream& os, const MemBarrierKind& kind) {
   }
 }
 
+// Check that intrinsic enum values fit within space set aside in ArtMethod modifier flags.
+#define CHECK_INTRINSICS_ENUM_VALUES(Name, InvokeType, _, SideEffects, Exceptions, ...) \
+  static_assert( \
+    static_cast<uint32_t>(Intrinsics::k ## Name) <= (kAccIntrinsicBits >> CTZ(kAccIntrinsicBits)), \
+    "Instrinsics enumeration space overflow.");
+#include "intrinsics_list.h"
+  INTRINSICS_LIST(CHECK_INTRINSICS_ENUM_VALUES)
+#undef INTRINSICS_LIST
+#undef CHECK_INTRINSICS_ENUM_VALUES
+
+// Function that returns whether an intrinsic needs an environment or not.
+static inline IntrinsicNeedsEnvironmentOrCache NeedsEnvironmentOrCacheIntrinsic(Intrinsics i) {
+  switch (i) {
+    case Intrinsics::kNone:
+      return kNeedsEnvironmentOrCache;  // Non-sensical for intrinsic.
+#define OPTIMIZING_INTRINSICS(Name, InvokeType, NeedsEnvOrCache, SideEffects, Exceptions, ...) \
+    case Intrinsics::k ## Name: \
+      return NeedsEnvOrCache;
+#include "intrinsics_list.h"
+      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
+#undef INTRINSICS_LIST
+#undef OPTIMIZING_INTRINSICS
+  }
+  return kNeedsEnvironmentOrCache;
+}
+
+// Function that returns whether an intrinsic has side effects.
+static inline IntrinsicSideEffects GetSideEffectsIntrinsic(Intrinsics i) {
+  switch (i) {
+    case Intrinsics::kNone:
+      return kAllSideEffects;
+#define OPTIMIZING_INTRINSICS(Name, InvokeType, NeedsEnvOrCache, SideEffects, Exceptions, ...) \
+    case Intrinsics::k ## Name: \
+      return SideEffects;
+#include "intrinsics_list.h"
+      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
+#undef INTRINSICS_LIST
+#undef OPTIMIZING_INTRINSICS
+  }
+  return kAllSideEffects;
+}
+
+// Function that returns whether an intrinsic can throw exceptions.
+static inline IntrinsicExceptions GetExceptionsIntrinsic(Intrinsics i) {
+  switch (i) {
+    case Intrinsics::kNone:
+      return kCanThrow;
+#define OPTIMIZING_INTRINSICS(Name, InvokeType, NeedsEnvOrCache, SideEffects, Exceptions, ...) \
+    case Intrinsics::k ## Name: \
+      return Exceptions;
+#include "intrinsics_list.h"
+      INTRINSICS_LIST(OPTIMIZING_INTRINSICS)
+#undef INTRINSICS_LIST
+#undef OPTIMIZING_INTRINSICS
+  }
+  return kCanThrow;
+}
+
+void HInvoke::SetResolvedMethod(ArtMethod* method) {
+  // TODO: b/65872996 The intent is that polymorphic signature methods should
+  // be compiler intrinsics. At present, they are only interpreter intrinsics.
+  if (method != nullptr &&
+      method->IsIntrinsic() &&
+      !method->IsPolymorphicSignature()) {
+    Intrinsics intrinsic = static_cast<Intrinsics>(method->GetIntrinsic());
+    SetIntrinsic(intrinsic,
+                 NeedsEnvironmentOrCacheIntrinsic(intrinsic),
+                 GetSideEffectsIntrinsic(intrinsic),
+                 GetExceptionsIntrinsic(intrinsic));
+  }
+  resolved_method_ = method;
+}
+
 }  // namespace art
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index 68f1a2406a..4ae7915fc7 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -29,6 +29,7 @@
 #include "base/quasi_atomic.h"
 #include "base/stl_util.h"
 #include "base/transform_array_ref.h"
+#include "art_method.h"
 #include "data_type.h"
 #include "deoptimization_kind.h"
 #include "dex/dex_file.h"
@@ -4322,7 +4323,7 @@ class HInvoke : public HVariableInputSizeInstruction {
   bool IsIntrinsic() const { return intrinsic_ != Intrinsics::kNone; }
 
   ArtMethod* GetResolvedMethod() const { return resolved_method_; }
-  void SetResolvedMethod(ArtMethod* method) { resolved_method_ = method; }
+  void SetResolvedMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
 
   DECLARE_ABSTRACT_INSTRUCTION(Invoke);
 
@@ -4354,12 +4355,14 @@ class HInvoke : public HVariableInputSizeInstruction {
           number_of_arguments + number_of_other_inputs,
           kArenaAllocInvokeInputs),
       number_of_arguments_(number_of_arguments),
-      resolved_method_(resolved_method),
       dex_method_index_(dex_method_index),
       intrinsic_(Intrinsics::kNone),
       intrinsic_optimizations_(0) {
     SetPackedField<InvokeTypeField>(invoke_type);
     SetPackedFlag<kFlagCanThrow>(true);
+    // Check mutator lock, constructors lack annotalysis support.
+    Locks::mutator_lock_->AssertNotExclusiveHeld(Thread::Current());
+    SetResolvedMethod(resolved_method);
   }
 
   DEFAULT_COPY_CONSTRUCTOR(Invoke);
diff --git a/compiler/optimizing/optimization.cc b/compiler/optimizing/optimization.cc
index 75466a3cba..4b0941b4ff 100644
--- a/compiler/optimizing/optimization.cc
+++ b/compiler/optimizing/optimization.cc
@@ -88,8 +88,6 @@ const char* OptimizationPassName(OptimizationPass pass) {
       return HSelectGenerator::kSelectGeneratorPassName;
     case OptimizationPass::kInstructionSimplifier:
       return InstructionSimplifier::kInstructionSimplifierPassName;
-    case OptimizationPass::kIntrinsicsRecognizer:
-      return IntrinsicsRecognizer::kIntrinsicsRecognizerPassName;
     case OptimizationPass::kCHAGuardOptimization:
       return CHAGuardOptimization::kCHAGuardOptimizationPassName;
     case OptimizationPass::kCodeSinking:
@@ -139,7 +137,6 @@ OptimizationPass OptimizationPassByName(const std::string& pass_name) {
   X(OptimizationPass::kInductionVarAnalysis);
   X(OptimizationPass::kInliner);
   X(OptimizationPass::kInstructionSimplifier);
-  X(OptimizationPass::kIntrinsicsRecognizer);
   X(OptimizationPass::kInvariantCodeMotion);
   X(OptimizationPass::kLoadStoreAnalysis);
   X(OptimizationPass::kLoadStoreElimination);
@@ -267,9 +264,6 @@ ArenaVector<HOptimization*> ConstructOptimizations(
       case OptimizationPass::kInstructionSimplifier:
         opt = new (allocator) InstructionSimplifier(graph, codegen, stats, pass_name);
         break;
-      case OptimizationPass::kIntrinsicsRecognizer:
-        opt = new (allocator) IntrinsicsRecognizer(graph, stats, pass_name);
-        break;
       case OptimizationPass::kCHAGuardOptimization:
         opt = new (allocator) CHAGuardOptimization(graph, pass_name);
         break;
diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h
index c258d516de..ced383fdd6 100644
--- a/compiler/optimizing/optimization.h
+++ b/compiler/optimizing/optimization.h
@@ -77,7 +77,6 @@ enum class OptimizationPass {
   kInductionVarAnalysis,
   kInliner,
   kInstructionSimplifier,
-  kIntrinsicsRecognizer,
   kInvariantCodeMotion,
   kLoadStoreAnalysis,
   kLoadStoreElimination,
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index 9ae025b3fe..95f2d0367f 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -623,7 +623,6 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph,
 
   OptimizationDef optimizations[] = {
     // Initial optimizations.
-    OptDef(OptimizationPass::kIntrinsicsRecognizer),
     OptDef(OptimizationPass::kConstantFolding),
     OptDef(OptimizationPass::kInstructionSimplifier),
     OptDef(OptimizationPass::kDeadCodeElimination,
@@ -944,9 +943,8 @@ CodeGenerator* OptimizingCompiler::TryCompileIntrinsic(
   }
 
   OptimizationDef optimizations[] = {
-    OptDef(OptimizationPass::kIntrinsicsRecognizer),
-    // Some intrinsics are converted to HIR by the simplifier and the codegen also
-    // has a few assumptions that only the instruction simplifier can satisfy.
+    // The codegen has a few assumptions that only the instruction simplifier
+    // can satisfy.
     OptDef(OptimizationPass::kInstructionSimplifier),
   };
   RunOptimizations(graph,
diff --git a/test/004-checker-UnsafeTest18/src/Main.java b/test/004-checker-UnsafeTest18/src/Main.java
index 282f9ce0d0..927d0da975 100644
--- a/test/004-checker-UnsafeTest18/src/Main.java
+++ b/test/004-checker-UnsafeTest18/src/Main.java
@@ -47,21 +47,21 @@ public class Main {
   // Setters.
   //
 
-  /// CHECK-START: int Main.set32(java.lang.Object, long, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.set32(java.lang.Object, long, int) builder (after)
   /// CHECK-DAG: <<Result:i\d+>> InvokeVirtual intrinsic:UnsafeGetAndSetInt
   /// CHECK-DAG:                 Return [<<Result>>]
   private static int set32(Object o, long offset, int newValue) {
     return unsafe.getAndSetInt(o, offset, newValue);
   }
 
-  /// CHECK-START: long Main.set64(java.lang.Object, long, long) intrinsics_recognition (after)
+  /// CHECK-START: long Main.set64(java.lang.Object, long, long) builder (after)
   /// CHECK-DAG: <<Result:j\d+>> InvokeVirtual intrinsic:UnsafeGetAndSetLong
   /// CHECK-DAG:                 Return [<<Result>>]
   private static long set64(Object o, long offset, long newValue) {
     return unsafe.getAndSetLong(o, offset, newValue);
   }
 
-  /// CHECK-START: java.lang.Object Main.setObj(java.lang.Object, long, java.lang.Object) intrinsics_recognition (after)
+  /// CHECK-START: java.lang.Object Main.setObj(java.lang.Object, long, java.lang.Object) builder (after)
   /// CHECK-DAG: <<Result:l\d+>> InvokeVirtual intrinsic:UnsafeGetAndSetObject
   /// CHECK-DAG:                 Return [<<Result>>]
   private static Object setObj(Object o, long offset, Object newValue) {
@@ -72,14 +72,14 @@ public class Main {
   // Adders.
   //
 
-  /// CHECK-START: int Main.add32(java.lang.Object, long, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.add32(java.lang.Object, long, int) builder (after)
   /// CHECK-DAG: <<Result:i\d+>> InvokeVirtual intrinsic:UnsafeGetAndAddInt
   /// CHECK-DAG:                 Return [<<Result>>]
   private static int add32(Object o, long offset, int delta) {
     return unsafe.getAndAddInt(o, offset, delta);
   }
 
-  /// CHECK-START: long Main.add64(java.lang.Object, long, long) intrinsics_recognition (after)
+  /// CHECK-START: long Main.add64(java.lang.Object, long, long) builder (after)
   /// CHECK-DAG: <<Result:j\d+>> InvokeVirtual intrinsic:UnsafeGetAndAddLong
   /// CHECK-DAG:                 Return [<<Result>>]
   private static long add64(Object o, long offset, long delta) {
@@ -90,7 +90,7 @@ public class Main {
   // Fences (native).
   //
 
-  /// CHECK-START: void Main.load() intrinsics_recognition (after)
+  /// CHECK-START: void Main.load() builder (after)
   /// CHECK-DAG: InvokeVirtual intrinsic:UnsafeLoadFence
   //
   /// CHECK-START: void Main.load() instruction_simplifier (after)
@@ -102,7 +102,7 @@ public class Main {
     unsafe.loadFence();
   }
 
-  /// CHECK-START: void Main.store() intrinsics_recognition (after)
+  /// CHECK-START: void Main.store() builder (after)
   /// CHECK-DAG: InvokeVirtual intrinsic:UnsafeStoreFence
   //
   /// CHECK-START: void Main.store() instruction_simplifier (after)
@@ -114,7 +114,7 @@ public class Main {
     unsafe.storeFence();
   }
 
-  /// CHECK-START: void Main.full() intrinsics_recognition (after)
+  /// CHECK-START: void Main.full() builder (after)
   /// CHECK-DAG: InvokeVirtual intrinsic:UnsafeFullFence
   //
   /// CHECK-START: void Main.full() instruction_simplifier (after)
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index 3ccfce4de1..6c75962b75 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -135,11 +135,7 @@ public class Main {
     }
   }
 
-  /// CHECK-START: int Main.returnAbs(int) intrinsics_recognition (before)
-  /// CHECK-DAG:     <<Result:i\d+>>      InvokeStaticOrDirect
-  /// CHECK-DAG:                          Return [<<Result>>]
-
-  /// CHECK-START: int Main.returnAbs(int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.returnAbs(int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>      InvokeStaticOrDirect intrinsic:MathAbsInt
   /// CHECK-DAG:                          Return [<<Result>>]
 
diff --git a/test/564-checker-bitcount/src/Main.java b/test/564-checker-bitcount/src/Main.java
index aad9689a1e..e022d9dd5c 100644
--- a/test/564-checker-bitcount/src/Main.java
+++ b/test/564-checker-bitcount/src/Main.java
@@ -21,7 +21,7 @@ public class Main {
   // CHECK-DAG: popcnt
 
 
-  /// CHECK-START: int Main.$noinline$BitCountBoolean(boolean) intrinsics_recognition (after)
+  /// CHECK-START: int Main.$noinline$BitCountBoolean(boolean) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect intrinsic:IntegerBitCount
   /// CHECK-DAG:                      Return [<<Result>>]
   private static int $noinline$BitCountBoolean(boolean x) {
@@ -29,7 +29,7 @@ public class Main {
     return Integer.bitCount(x ? 1 : 0);
   }
 
-  /// CHECK-START: int Main.$noinline$BitCountByte(byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.$noinline$BitCountByte(byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect intrinsic:IntegerBitCount
   /// CHECK-DAG:                      Return [<<Result>>]
   private static int $noinline$BitCountByte(byte x) {
@@ -37,7 +37,7 @@ public class Main {
     return Integer.bitCount(x);
   }
 
-  /// CHECK-START: int Main.$noinline$BitCountShort(short) intrinsics_recognition (after)
+  /// CHECK-START: int Main.$noinline$BitCountShort(short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect intrinsic:IntegerBitCount
   /// CHECK-DAG:                      Return [<<Result>>]
   private static int $noinline$BitCountShort(short x) {
@@ -45,7 +45,7 @@ public class Main {
     return Integer.bitCount(x);
   }
 
-  /// CHECK-START: int Main.$noinline$BitCountChar(char) intrinsics_recognition (after)
+  /// CHECK-START: int Main.$noinline$BitCountChar(char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect intrinsic:IntegerBitCount
   /// CHECK-DAG:                      Return [<<Result>>]
   private static int $noinline$BitCountChar(char x) {
@@ -53,7 +53,7 @@ public class Main {
     return Integer.bitCount(x);
   }
 
-  /// CHECK-START: int Main.$noinline$BitCountInt(int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.$noinline$BitCountInt(int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect intrinsic:IntegerBitCount
   /// CHECK-DAG:                      Return [<<Result>>]
   private static int $noinline$BitCountInt(int x) {
@@ -61,7 +61,7 @@ public class Main {
     return Integer.bitCount(x);
   }
 
-  /// CHECK-START: int Main.$noinline$BitCountLong(long) intrinsics_recognition (after)
+  /// CHECK-START: int Main.$noinline$BitCountLong(long) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect intrinsic:LongBitCount
   /// CHECK-DAG:                      Return [<<Result>>]
   private static int $noinline$BitCountLong(long x) {
diff --git a/test/565-checker-rotate/smali/Main2.smali b/test/565-checker-rotate/smali/Main2.smali
index 98eaf11b1d..768c9d0454 100644
--- a/test/565-checker-rotate/smali/Main2.smali
+++ b/test/565-checker-rotate/smali/Main2.smali
@@ -15,7 +15,7 @@
 .class public LMain2;
 .super Ljava/lang/Object;
 
-## CHECK-START: int Main2.rotateLeftBoolean(boolean, int) intrinsics_recognition (after)
+## CHECK-START: int Main2.rotateLeftBoolean(boolean, int) builder (after)
 ## CHECK:         <<ArgVal:z\d+>>  ParameterValue
 ## CHECK:         <<ArgDist:i\d+>> ParameterValue
 ## CHECK-DAG:     <<Zero:i\d+>>    IntConstant 0
@@ -90,7 +90,7 @@
     goto :goto_3
 .end method
 
-## CHECK-START: int Main2.rotateRightBoolean(boolean, int) intrinsics_recognition (after)
+## CHECK-START: int Main2.rotateRightBoolean(boolean, int) builder (after)
 ## CHECK:         <<ArgVal:z\d+>>  ParameterValue
 ## CHECK:         <<ArgDist:i\d+>> ParameterValue
 ## CHECK-DAG:     <<Zero:i\d+>>    IntConstant 0
diff --git a/test/565-checker-rotate/src-art/Main.java b/test/565-checker-rotate/src-art/Main.java
index f6f281bdfd..867feb8ea8 100644
--- a/test/565-checker-rotate/src-art/Main.java
+++ b/test/565-checker-rotate/src-art/Main.java
@@ -20,7 +20,7 @@ public class Main {
 
   private static Class main2;
 
-  /// CHECK-START: int Main.rotateLeftByte(byte, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
   /// CHECK:         <<ArgVal:b\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
@@ -40,7 +40,7 @@ public class Main {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftShort(short, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
   /// CHECK:         <<ArgVal:s\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
@@ -60,7 +60,7 @@ public class Main {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftChar(char, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
   /// CHECK:         <<ArgVal:c\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
@@ -80,7 +80,7 @@ public class Main {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateLeftInt(int, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
@@ -100,7 +100,7 @@ public class Main {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: long Main.rotateLeftLong(long, int) intrinsics_recognition (after)
+  /// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
   /// CHECK:         <<ArgVal:j\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:j\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:LongRotateLeft
@@ -120,7 +120,7 @@ public class Main {
     return Long.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightByte(byte, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
   /// CHECK:         <<ArgVal:b\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
@@ -139,7 +139,7 @@ public class Main {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightShort(short, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
   /// CHECK:         <<ArgVal:s\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
@@ -158,7 +158,7 @@ public class Main {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightChar(char, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
   /// CHECK:         <<ArgVal:c\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
@@ -177,7 +177,7 @@ public class Main {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightInt(int, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
@@ -196,7 +196,7 @@ public class Main {
     return Integer.rotateRight(value, distance);
   }
 
-  /// CHECK-START: long Main.rotateRightLong(long, int) intrinsics_recognition (after)
+  /// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
   /// CHECK:         <<ArgVal:j\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:j\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:LongRotateRight
@@ -216,7 +216,7 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:b\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
@@ -236,7 +236,7 @@ public class Main {
     return Integer.rotateLeft(value, distance);
   }
 
-  /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
   /// CHECK:         <<ArgVal:i\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:b\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
diff --git a/test/566-checker-signum/smali/Main2.smali b/test/566-checker-signum/smali/Main2.smali
index ec63cf850e..767bed213c 100644
--- a/test/566-checker-signum/smali/Main2.smali
+++ b/test/566-checker-signum/smali/Main2.smali
@@ -15,7 +15,7 @@
 .class public LMain2;
 .super Ljava/lang/Object;
 
-## CHECK-START: int Main2.signBoolean(boolean) intrinsics_recognition (after)
+## CHECK-START: int Main2.signBoolean(boolean) builder (after)
 ## CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
 ## CHECK-DAG:     <<One:i\d+>>    IntConstant 1
 ## CHECK-DAG:     <<Phi:i\d+>>    Phi [<<One>>,<<Zero>>]
diff --git a/test/566-checker-signum/src-art/Main.java b/test/566-checker-signum/src-art/Main.java
index f1e1e1bf6e..ea01785331 100644
--- a/test/566-checker-signum/src-art/Main.java
+++ b/test/566-checker-signum/src-art/Main.java
@@ -18,7 +18,7 @@ import java.lang.reflect.Method;
 
 public class Main {
 
-  /// CHECK-START: int Main.signByte(byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.signByte(byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -33,7 +33,7 @@ public class Main {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signShort(short) intrinsics_recognition (after)
+  /// CHECK-START: int Main.signShort(short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -48,7 +48,7 @@ public class Main {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signChar(char) intrinsics_recognition (after)
+  /// CHECK-START: int Main.signChar(char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -63,7 +63,7 @@ public class Main {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signInt(int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.signInt(int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -78,7 +78,7 @@ public class Main {
     return Integer.signum(x);
   }
 
-  /// CHECK-START: int Main.signLong(long) intrinsics_recognition (after)
+  /// CHECK-START: int Main.signLong(long) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:LongSignum
   /// CHECK-DAG:                     Return [<<Result>>]
 
diff --git a/test/567-checker-compare/smali/Smali.smali b/test/567-checker-compare/smali/Smali.smali
index 94b1f13482..fb6d241cc6 100644
--- a/test/567-checker-compare/smali/Smali.smali
+++ b/test/567-checker-compare/smali/Smali.smali
@@ -15,7 +15,7 @@
 .class public LSmali;
 .super Ljava/lang/Object;
 
-##  CHECK-START: int Smali.compareBooleans(boolean, boolean) intrinsics_recognition (after)
+##  CHECK-START: int Smali.compareBooleans(boolean, boolean) builder (after)
 ##  CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
 ##  CHECK-DAG:     <<One:i\d+>>    IntConstant 1
 ##  CHECK-DAG:     <<PhiX:i\d+>>   Phi [<<One>>,<<Zero>>]
diff --git a/test/567-checker-compare/src/Main.java b/test/567-checker-compare/src/Main.java
index f43ac300f7..a3ff005790 100644
--- a/test/567-checker-compare/src/Main.java
+++ b/test/567-checker-compare/src/Main.java
@@ -20,7 +20,7 @@ public class Main {
 
   public static boolean doThrow = false;
 
-  /// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) intrinsics_recognition (after)
+  /// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) builder (after)
   /// CHECK-DAG:     <<ArgX:i\d+>>   ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<Cmp:i\d+>>    InvokeStaticOrDirect [<<ArgX>>,<<Zero>>{{(,[ij]\d+)?}}] intrinsic:IntegerCompare
@@ -65,7 +65,7 @@ public class Main {
     return (Integer) m.invoke(null, x, y);
   }
 
-  /// CHECK-START: int Main.compareBytes(byte, byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -80,7 +80,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareShorts(short, short) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareShorts(short, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -95,7 +95,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareChars(char, char) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareChars(char, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -110,7 +110,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareInts(int, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareInts(int, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -125,7 +125,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareLongs(long, long) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareLongs(long, long) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:LongCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -141,7 +141,7 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareByteShort(byte, short) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -156,7 +156,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareByteChar(byte, char) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -171,7 +171,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareByteInt(byte, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -187,7 +187,7 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareShortByte(short, byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -202,7 +202,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareShortChar(short, char) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareShortChar(short, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -217,7 +217,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareShortInt(short, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareShortInt(short, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -233,7 +233,7 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareCharByte(char, byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -248,7 +248,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareCharShort(char, short) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareCharShort(char, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -263,7 +263,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareCharInt(char, int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareCharInt(char, int) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -279,7 +279,7 @@ public class Main {
   }
 
 
-  /// CHECK-START: int Main.compareIntByte(int, byte) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -294,7 +294,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareIntShort(int, short) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareIntShort(int, short) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
@@ -309,7 +309,7 @@ public class Main {
     return Integer.compare(x, y);
   }
 
-  /// CHECK-START: int Main.compareIntChar(int, char) intrinsics_recognition (after)
+  /// CHECK-START: int Main.compareIntChar(int, char) builder (after)
   /// CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
   /// CHECK-DAG:                     Return [<<Result>>]
 
diff --git a/test/568-checker-onebit/src/Main.java b/test/568-checker-onebit/src/Main.java
index 6ce4ffbd3f..e4d3e88ca7 100644
--- a/test/568-checker-onebit/src/Main.java
+++ b/test/568-checker-onebit/src/Main.java
@@ -16,28 +16,28 @@
 
 public class Main {
 
-  /// CHECK-START: int Main.hi32(int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.hi32(int) builder (after)
   /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerHighestOneBit
   /// CHECK-DAG:                 Return [<<Result>>]
   private static int hi32(int x) {
     return Integer.highestOneBit(x);
   }
 
-  /// CHECK-START: int Main.lo32(int) intrinsics_recognition (after)
+  /// CHECK-START: int Main.lo32(int) builder (after)
   /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerLowestOneBit
   /// CHECK-DAG:                 Return [<<Result>>]
   private static int lo32(int x) {
     return Integer.lowestOneBit(x);
   }
 
-  /// CHECK-START: long Main.hi64(long) intrinsics_recognition (after)
+  /// CHECK-START: long Main.hi64(long) builder (after)
   /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect intrinsic:LongHighestOneBit
   /// CHECK-DAG:                 Return [<<Result>>]
   private static long hi64(long x) {
     return Long.highestOneBit(x);
   }
 
-  /// CHECK-START: long Main.lo64(long) intrinsics_recognition (after)
+  /// CHECK-START: long Main.lo64(long) builder (after)
   /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect intrinsic:LongLowestOneBit
   /// CHECK-DAG:                 Return [<<Result>>]
   private static long lo64(long x) {
diff --git a/test/580-checker-round/src/Main.java b/test/580-checker-round/src/Main.java
index 83bc55c480..a6752b5873 100644
--- a/test/580-checker-round/src/Main.java
+++ b/test/580-checker-round/src/Main.java
@@ -16,14 +16,14 @@
 
 public class Main {
 
-  /// CHECK-START: int Main.round32(float) intrinsics_recognition (after)
+  /// CHECK-START: int Main.round32(float) builder (after)
   /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:MathRoundFloat
   /// CHECK-DAG:                 Return [<<Result>>]
   private static int round32(float f) {
     return Math.round(f);
   }
 
-  /// CHECK-START: long Main.round64(double) intrinsics_recognition (after)
+  /// CHECK-START: long Main.round64(double) builder (after)
   /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect intrinsic:MathRoundDouble
   /// CHECK-DAG:                 Return [<<Result>>]
   private static long round64(double d) {
diff --git a/test/580-checker-string-fact-intrinsics/src-art/Main.java b/test/580-checker-string-fact-intrinsics/src-art/Main.java
index a2e34bffd0..d0750f9ae8 100644
--- a/test/580-checker-string-fact-intrinsics/src-art/Main.java
+++ b/test/580-checker-string-fact-intrinsics/src-art/Main.java
@@ -17,9 +17,6 @@
 public class Main {
 
   /// CHECK-START: void Main.testNewStringFromBytes() builder (after)
-  /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromBytes intrinsic:None
-
-  /// CHECK-START: void Main.testNewStringFromBytes() intrinsics_recognition (after)
   /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromBytes intrinsic:StringNewStringFromBytes
 
   public static void testNewStringFromBytes() {
@@ -51,9 +48,6 @@ public class Main {
   /// CHECK-START: void Main.testNewStringFromChars() builder (after)
   /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromChars intrinsic:None
 
-  /// CHECK-START: void Main.testNewStringFromChars() intrinsics_recognition (after)
-  /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromChars intrinsic:None
-
   /// CHECK-START: void Main.testNewStringFromChars() inliner (after)
   /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromChars intrinsic:None
 
@@ -64,9 +58,6 @@ public class Main {
   }
 
   /// CHECK-START: void Main.testNewStringFromString() builder (after)
-  /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromString intrinsic:None
-
-  /// CHECK-START: void Main.testNewStringFromString() intrinsics_recognition (after)
   /// CHECK-DAG:     InvokeStaticOrDirect method_name:java.lang.StringFactory.newStringFromString intrinsic:StringNewStringFromString
 
   public static void testNewStringFromString() {
diff --git a/test/624-checker-stringops/smali/Smali.smali b/test/624-checker-stringops/smali/Smali.smali
index 7b063c0c52..8600a0a065 100644
--- a/test/624-checker-stringops/smali/Smali.smali
+++ b/test/624-checker-stringops/smali/Smali.smali
@@ -16,23 +16,13 @@
 .class public LSmali;
 .super Ljava/lang/Object;
 
-##  CHECK-START: int Smali.bufferLen2() instruction_simplifier (before)
+##  CHECK-START: int Smali.bufferLen2() builder (after)
 ##  CHECK-DAG: <<New:l\d+>>     NewInstance
 ##  CHECK-DAG: <<String1:l\d+>> LoadString
-##  CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<New>>,<<String1>>]   intrinsic:StringBufferAppend
+##  CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<New>>,<<String1>>]     intrinsic:StringBufferAppend
 ##  CHECK-DAG: <<String2:l\d+>> LoadString
-##  CHECK-DAG: <<Null1:l\d+>>   NullCheck     [<<Append1>>]
-##  CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Null1>>,<<String2>>] intrinsic:StringBufferAppend
-##  CHECK-DAG: <<Null2:l\d+>>   NullCheck     [<<Append2>>]
-##  CHECK-DAG:                  InvokeVirtual [<<Null2>>]             intrinsic:StringBufferLength
-
-##  CHECK-START: int Smali.bufferLen2() instruction_simplifier (after)
-##  CHECK-DAG: <<New:l\d+>>     NewInstance
-##  CHECK-DAG: <<String1:l\d+>> LoadString
-##  CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<New>>,<<String1>>] intrinsic:StringBufferAppend
-##  CHECK-DAG: <<String2:l\d+>> LoadString
-##  CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<New>>,<<String2>>] intrinsic:StringBufferAppend
-##  CHECK-DAG:                  InvokeVirtual [<<New>>]             intrinsic:StringBufferLength
+##  CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Append1>>,<<String2>>] intrinsic:StringBufferAppend
+##  CHECK-DAG:                  InvokeVirtual [<<Append2>>]             intrinsic:StringBufferLength
 .method public static bufferLen2()I
     .registers 3
 
@@ -57,12 +47,10 @@
 ## CHECK-START: int Smali.builderLen2() instruction_simplifier (before)
 ## CHECK-DAG: <<New:l\d+>>     NewInstance
 ## CHECK-DAG: <<String1:l\d+>> LoadString
-## CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<New>>,<<String1>>]   intrinsic:StringBuilderAppend
+## CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<New>>,<<String1>>]     intrinsic:StringBuilderAppend
 ## CHECK-DAG: <<String2:l\d+>> LoadString
-## CHECK-DAG: <<Null2:l\d+>>   NullCheck     [<<Append1>>]
-## CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Null2>>,<<String2>>] intrinsic:StringBuilderAppend
-## CHECK-DAG: <<Null3:l\d+>>   NullCheck     [<<Append2>>]
-## CHECK-DAG:                  InvokeVirtual [<<Null3>>]             intrinsic:StringBuilderLength
+## CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Append1>>,<<String2>>] intrinsic:StringBuilderAppend
+## CHECK-DAG:                  InvokeVirtual [<<Append2>>]             intrinsic:StringBuilderLength
 
 ## CHECK-START: int Smali.builderLen2() instruction_simplifier (after)
 ## CHECK-DAG: <<New:l\d+>>     NewInstance
@@ -93,18 +81,16 @@
 .end method
 
 ## CHECK-START: int Smali.bufferLoopAppender() instruction_simplifier (before)
-## CHECK-DAG: <<New:l\d+>>     NewInstance                                                         loop:none
-## CHECK-DAG: <<String1:l\d+>> LoadString                                                          loop:<<Loop:B\d+>>
-## CHECK-DAG: <<Null1:l\d+>>   NullCheck     [<<New>>]                                             loop:<<Loop>>
-## CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<Null1>>,<<String1>>] intrinsic:StringBufferAppend  loop:<<Loop>>
-## CHECK-DAG: <<String2:l\d+>> LoadString                                                          loop:<<Loop>>
-## CHECK-DAG: <<Null2:l\d+>>   NullCheck     [<<Append1>>]                                         loop:<<Loop>>
-## CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Null2>>,<<String2>>] intrinsic:StringBufferAppend  loop:<<Loop>>
-## CHECK-DAG: <<String3:l\d+>> LoadString                                                          loop:<<Loop>>
-## CHECK-DAG: <<Null3:l\d+>>   NullCheck     [<<Append2>>]                                         loop:<<Loop>>
-## CHECK-DAG: <<Append3:l\d+>> InvokeVirtual [<<Null3>>,<<String3>>] intrinsic:StringBufferAppend  loop:<<Loop>>
-## CHECK-DAG: <<Null4:l\d+>>   NullCheck     [<<New>>]                                             loop:none
-## CHECK-DAG:                  InvokeVirtual [<<Null4>>]             intrinsic:StringBufferLength  loop:none
+## CHECK-DAG: <<New:l\d+>>     NewInstance                                                           loop:none
+## CHECK-DAG: <<String1:l\d+>> LoadString                                                            loop:<<Loop:B\d+>>
+## CHECK-DAG: <<Null1:l\d+>>   NullCheck     [<<New>>]                                               loop:<<Loop>>
+## CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<Null1>>,<<String1>>] intrinsic:StringBufferAppend    loop:<<Loop>>
+## CHECK-DAG: <<String2:l\d+>> LoadString                                                            loop:<<Loop>>
+## CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Append1>>,<<String2>>] intrinsic:StringBufferAppend  loop:<<Loop>>
+## CHECK-DAG: <<String3:l\d+>> LoadString                                                            loop:<<Loop>>
+## CHECK-DAG: <<Append3:l\d+>> InvokeVirtual [<<Append2>>,<<String3>>] intrinsic:StringBufferAppend  loop:<<Loop>>
+## CHECK-DAG: <<Null4:l\d+>>   NullCheck     [<<New>>]                                               loop:none
+## CHECK-DAG:                  InvokeVirtual [<<Null4>>]             intrinsic:StringBufferLength    loop:none
 
 ## CHECK-START: int Smali.bufferLoopAppender() instruction_simplifier (after)
 ## CHECK-DAG: <<New:l\d+>>     NewInstance                                                       loop:none
@@ -152,18 +138,16 @@
 .end method
 
 ## CHECK-START: int Smali.builderLoopAppender() instruction_simplifier (before)
-## CHECK-DAG: <<New:l\d+>>     NewInstance                                                         loop:none
-## CHECK-DAG: <<String1:l\d+>> LoadString                                                          loop:<<Loop:B\d+>>
-## CHECK-DAG: <<Null1:l\d+>>   NullCheck     [<<New>>]                                             loop:<<Loop>>
-## CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<Null1>>,<<String1>>] intrinsic:StringBuilderAppend loop:<<Loop>>
-## CHECK-DAG: <<String2:l\d+>> LoadString                                                          loop:<<Loop>>
-## CHECK-DAG: <<Null2:l\d+>>   NullCheck     [<<Append1>>]                                         loop:<<Loop>>
-## CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Null2>>,<<String2>>] intrinsic:StringBuilderAppend loop:<<Loop>>
-## CHECK-DAG: <<String3:l\d+>> LoadString                                                          loop:<<Loop>>
-## CHECK-DAG: <<Null3:l\d+>>   NullCheck     [<<Append2>>]                                         loop:<<Loop>>
-## CHECK-DAG: <<Append3:l\d+>> InvokeVirtual [<<Null3>>,<<String3>>] intrinsic:StringBuilderAppend loop:<<Loop>>
-## CHECK-DAG: <<Null4:l\d+>>   NullCheck     [<<New>>]                                             loop:none
-## CHECK-DAG:                  InvokeVirtual [<<Null4>>]             intrinsic:StringBuilderLength loop:none
+## CHECK-DAG: <<New:l\d+>>     NewInstance                                                           loop:none
+## CHECK-DAG: <<String1:l\d+>> LoadString                                                            loop:<<Loop:B\d+>>
+## CHECK-DAG: <<Null1:l\d+>>   NullCheck     [<<New>>]                                               loop:<<Loop>>
+## CHECK-DAG: <<Append1:l\d+>> InvokeVirtual [<<Null1>>,<<String1>>]   intrinsic:StringBuilderAppend loop:<<Loop>>
+## CHECK-DAG: <<String2:l\d+>> LoadString                                                            loop:<<Loop>>
+## CHECK-DAG: <<Append2:l\d+>> InvokeVirtual [<<Append1>>,<<String2>>] intrinsic:StringBuilderAppend loop:<<Loop>>
+## CHECK-DAG: <<String3:l\d+>> LoadString                                                            loop:<<Loop>>
+## CHECK-DAG: <<Append3:l\d+>> InvokeVirtual [<<Append2>>,<<String3>>] intrinsic:StringBuilderAppend loop:<<Loop>>
+## CHECK-DAG: <<Null4:l\d+>>   NullCheck     [<<New>>]                                               loop:none
+## CHECK-DAG:                  InvokeVirtual [<<Null4>>]               intrinsic:StringBuilderLength loop:none
 
 ## CHECK-START: int Smali.builderLoopAppender() instruction_simplifier (after)
 ## CHECK-DAG: <<New:l\d+>>     NewInstance                                                       loop:none
diff --git a/test/631-checker-fp-abs/src/Main.java b/test/631-checker-fp-abs/src/Main.java
index 2db93b8248..2d04e36d02 100644
--- a/test/631-checker-fp-abs/src/Main.java
+++ b/test/631-checker-fp-abs/src/Main.java
@@ -31,7 +31,7 @@ public class Main {
 
   public static boolean doThrow = false;
 
-  /// CHECK-START: float Main.$opt$noinline$absSP(float) intrinsics_recognition (after)
+  /// CHECK-START: float Main.$opt$noinline$absSP(float) builder (after)
   /// CHECK-DAG: <<Result:f\d+>> InvokeStaticOrDirect intrinsic:MathAbsFloat
   /// CHECK-DAG:                 Return [<<Result>>]
   private static float $opt$noinline$absSP(float f) {
@@ -41,7 +41,7 @@ public class Main {
     return Math.abs(f);
   }
 
-  /// CHECK-START: double Main.$opt$noinline$absDP(double) intrinsics_recognition (after)
+  /// CHECK-START: double Main.$opt$noinline$absDP(double) builder (after)
   /// CHECK-DAG: <<Result:d\d+>> InvokeStaticOrDirect intrinsic:MathAbsDouble
   /// CHECK-DAG:                 Return [<<Result>>]
   private static double $opt$noinline$absDP(double d) {
diff --git a/test/638-checker-inline-cache-intrinsic/src/Main.java b/test/638-checker-inline-cache-intrinsic/src/Main.java
index 472cbf68bc..4a9aba570c 100644
--- a/test/638-checker-inline-cache-intrinsic/src/Main.java
+++ b/test/638-checker-inline-cache-intrinsic/src/Main.java
@@ -52,11 +52,11 @@ public class Main {
 
   /// CHECK-START: boolean Main.$noinline$stringEquals(java.lang.Object) inliner (after)
   /// CHECK:       Deoptimize
-  /// CHECK:       InvokeVirtual method_name:java.lang.Object.equals intrinsic:StringEquals
+  /// CHECK:       InvokeVirtual method_name:java.lang.String.equals intrinsic:StringEquals
 
   /// CHECK-START: boolean Main.$noinline$stringEquals(java.lang.Object) instruction_simplifier$after_inlining (after)
   /// CHECK:       Deoptimize
-  /// CHECK:       InvokeVirtual method_name:java.lang.Object.equals intrinsic:StringEquals
+  /// CHECK:       InvokeVirtual method_name:java.lang.String.equals intrinsic:StringEquals
 
   public static boolean $noinline$stringEquals(Object obj) {
     return obj.equals("def");
diff --git a/test/709-checker-varhandles/src/Main.java b/test/709-checker-varhandles/src/Main.java
index 46aaa38f4b..d0ea8345c3 100644
--- a/test/709-checker-varhandles/src/Main.java
+++ b/test/709-checker-varhandles/src/Main.java
@@ -28,7 +28,7 @@ public class Main {
   // Fences (native).
   //
 
-  /// CHECK-START: void Main.fullFence() intrinsics_recognition (after)
+  /// CHECK-START: void Main.fullFence() builder (after)
   /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleFullFence
   //
   /// CHECK-START: void Main.fullFence() instruction_simplifier (after)
@@ -40,7 +40,7 @@ public class Main {
       VarHandle.fullFence();
   }
 
-  /// CHECK-START: void Main.acquireFence() intrinsics_recognition (after)
+  /// CHECK-START: void Main.acquireFence() builder (after)
   /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleAcquireFence
   //
   /// CHECK-START: void Main.acquireFence() instruction_simplifier (after)
@@ -52,7 +52,7 @@ public class Main {
       VarHandle.acquireFence();
   }
 
-  /// CHECK-START: void Main.releaseFence() intrinsics_recognition (after)
+  /// CHECK-START: void Main.releaseFence() builder (after)
   /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleReleaseFence
   //
   /// CHECK-START: void Main.releaseFence() instruction_simplifier (after)
@@ -64,7 +64,7 @@ public class Main {
       VarHandle.releaseFence();
   }
 
-  /// CHECK-START: void Main.loadLoadFence() intrinsics_recognition (after)
+  /// CHECK-START: void Main.loadLoadFence() builder (after)
   /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleLoadLoadFence
   //
   /// CHECK-START: void Main.loadLoadFence() instruction_simplifier (after)
@@ -76,7 +76,7 @@ public class Main {
       VarHandle.loadLoadFence();
   }
 
-  /// CHECK-START: void Main.storeStoreFence() intrinsics_recognition (after)
+  /// CHECK-START: void Main.storeStoreFence() builder (after)
   /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleStoreStoreFence
   //
   /// CHECK-START: void Main.storeStoreFence() instruction_simplifier (after)