Inline Math.sqrt in new compilers.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
 #include "vm/handles_impl.h"
 #include "vm/object.h"
 
 namespace dart {
 
+// TODO(srdjan): Add _ByteArrayBase, get:length.
+
+#define RECOGNIZED_LIST(V)                                                     \
+  V(ObjectArray, get:length, ObjectArrayLength)                                \
+  V(ImmutableArray, get:length, ImmutableArrayLength)                          \
+  V(GrowableObjectArray, get:length, GrowableArrayLength)                      \
+  V(StringBase, get:length, StringBaseLength)                                  \
+  V(IntegerImplementation, toDouble, IntegerToDouble)                          \
+  V(Double, toDouble, DoubleToDouble)                                          \
+  V(Math, sqrt, MathSqrt)                                                      \
+
+// Class that recognizes the name and owner of a function and returns the
+// corresponding enum. See RECOGNIZED_LIST above for list of recognizable
+// functions.
+class MethodRecognizer : public AllStatic {
+ public:
+  enum Kind {
+    kUnknown,
+#define DEFINE_ENUM_LIST(class_name, function_name, enum_name) k##enum_name,
+RECOGNIZED_LIST(DEFINE_ENUM_LIST)
+#undef DEFINE_ENUM_LIST
+  };
+
+  static Kind RecognizeKind(const Function& function);
+  static const char* KindToCString(Kind kind);
+};
+
+
 class BitVector;
 class FlowGraphCompiler;
 class FlowGraphVisitor;
 class Function;
 class LocalVariable;
 class LocationSummary;
 
 // M is a two argument macro.  It is applied to each concrete value's
 // typename and classname.
 #define FOR_EACH_VALUE(M)                                                      \
@@ skipping 671 matching lines @@
  public:
   StaticCallComp(intptr_t token_index,
                  intptr_t try_index,
                  const Function& function,
                  const Array& argument_names,
                  ZoneGrowableArray<Value*>* arguments)
       : token_index_(token_index),
         try_index_(try_index),
         function_(function),
         argument_names_(argument_names),
-        arguments_(arguments) {
+        arguments_(arguments),
+        recognized_(MethodRecognizer::kUnknown) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle());
   }
 
   DECLARE_COMPUTATION(StaticCall)
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t token_index() const { return token_index_; }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
+  MethodRecognizer::Kind recognized() const { return recognized_; }
+  void set_recognized(MethodRecognizer::Kind kind) { recognized_ = kind; }
+
   virtual intptr_t InputCount() const;
   virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const intptr_t token_index_;
   const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<Value*>* arguments_;
+  MethodRecognizer::Kind recognized_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
 class LoadLocalComp : public TemplateComputation<0> {
  public:
   LoadLocalComp(const LocalVariable& local, intptr_t context_level)
       : local_(local),
         context_level_(context_level) { }
@@ skipping 1643 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_