Add flag --check-function-fingerprints, it checks all function fingerprints of the intrinsifier and…

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/code_observers.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/datastream.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/double_conversion.h"
 #include "vm/exceptions.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
+#include "vm/intermediate_language.h"
 #include "vm/intrinsifier.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
@@ skipping 6813 matching lines @@
       cls ^= anon_classes.At(i);
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
   return error.raw();
 }
 
+struct FpDiff {
+  FpDiff(int32_t old_, int32_t new_): old_fp(old_), new_fp(new_) {}
+  int32_t old_fp;
+  int32_t new_fp;
+};
+
+void Library::CheckFunctionFingerprints() {
+  GrowableArray<FpDiff> collected_fp_diffs;
+  Library& lib = Library::Handle();
+  Class& cls = Class::Handle();
+  Function& func = Function::Handle();
+  String& str = String::Handle();
+  bool has_errors = false;
+
+#define CHECK_FINGERPRINTS(class_name, function_name, dest, fp)                \
+  func = Function::null();                                                     \
+  if (strcmp(#class_name, "::") == 0) {                                        \
+    str = Symbols::New(#function_name);                                        \
+    func = lib.LookupFunctionAllowPrivate(str);                                \
+  } else {                                                                     \
+    str = String::New(#class_name);                                            \
+    cls = lib.LookupClassAllowPrivate(str);                                    \
+    if (!cls.IsNull()) {                                                       \
+      if (#function_name[0] == '.') {                                          \
+        str = String::New(#class_name#function_name);                          \
+      } else {                                                                 \
+        str = String::New(#function_name);                                     \
+      }                                                                        \
+      func = cls.LookupFunctionAllowPrivate(str);                              \
+    }                                                                          \
+  }                                                                            \
+  if (!func.IsNull() && (func.SourceFingerprint() != fp)) {                    \
+    has_errors = true;                                                         \
+    OS::Print("Wrong fingerprint for '%s': expecting %d found %d\n",           \
+        func.ToFullyQualifiedCString(), fp, func.SourceFingerprint());         \
+    collected_fp_diffs.Add(FpDiff(fp, func.SourceFingerprint()));              \
+  }                                                                            \
+
+  lib = Library::CoreLibrary();
+  CORE_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
+
+  RECOGNIZED_LIST(CHECK_FINGERPRINTS);
+
+  lib = Library::MathLibrary();
+  MATH_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
+
+  lib = Library::TypedDataLibrary();
+  TYPEDDATA_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
+
+#undef CHECK_FINGERPRINTS
+  if (has_errors) {
+    for (intptr_t i = 0; i < collected_fp_diffs.length(); i++) {
+      OS::Print("s/%d/%d/\n",
+          collected_fp_diffs[i].old_fp, collected_fp_diffs[i].new_fp);
+    }
+    OS::Print("\n")
+    FATAL("Fingerprint mismatch.");
+  }
+}
+
 
 RawInstructions* Instructions::New(intptr_t size) {
   ASSERT(Object::instructions_class() != Class::null());
   if (size < 0 || size > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Instructions::New: invalid size %"Pd"\n", size);
   }
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
@@ skipping 6243 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart