Add signMask getter to Float32x4

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1456 matching lines @@
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   intptr_t mask = 0;
   if (getter == MethodRecognizer::kFloat32x4Shuffle) {
+    // Extract shuffle mask.
     ASSERT(call->ArgumentCount() == 2);
-    // Extract shuffle mask.
     Definition* mask_definition = call->ArgumentAt(1);
     ASSERT(mask_definition->IsConstant());
     ConstantInstr* constant_instruction = mask_definition->AsConstant();
     const Object& constant_mask = constant_instruction->value();
     ASSERT(constant_mask.IsSmi());
     mask = Smi::Cast(constant_mask).Value();
     ASSERT(mask >= 0);
     ASSERT(mask <= 255);
   }
-  Float32x4ShuffleInstr* instr = new Float32x4ShuffleInstr(
-      getter,
-      new Value(call->ArgumentAt(0)),
-      mask,
-      call->deopt_id());
-  ReplaceCall(call, instr);
-  return true;
+  if ((getter == MethodRecognizer::kFloat32x4Shuffle)  ||
+      (getter == MethodRecognizer::kFloat32x4ShuffleX) ||
+      (getter == MethodRecognizer::kFloat32x4ShuffleY) ||
+      (getter == MethodRecognizer::kFloat32x4ShuffleZ) ||
+      (getter == MethodRecognizer::kFloat32x4ShuffleW)) {
+    Float32x4ShuffleInstr* instr = new Float32x4ShuffleInstr(
+        getter,
+        new Value(call->ArgumentAt(0)),
+        mask,
+        call->deopt_id());
+    ReplaceCall(call, instr);
+    return true;
+  } else if (getter == MethodRecognizer::kFloat32x4GetSignMask) {

[srdjan, 2013/08/16 00:19:59]

It may be better to do

if (getter == MethodRecognizer::kFloat32x4GetSignMask) {
...
} else {
  // ASSERT getter is one of the 5 legal values.
}

[Cutch, 2013/08/19 17:23:22]

Done.

+    Float32x4GetSignMaskInstr* instr = new Float32x4GetSignMaskInstr(
+        new Value(call->ArgumentAt(0)),
+        call->deopt_id());
+    ReplaceCall(call, instr);
+    return true;
+  } else {
+    UNIMPLEMENTED();
+    return false;
+  }
+  UNREACHABLE();
+  return false;
 }
 
 
 bool FlowGraphOptimizer::InlineUint32x4Getter(InstanceCallInstr* call,
                                               MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
@@ skipping 137 matching lines @@
       if (!ic_data.HasOneTarget()) {
         // Target is not only StringBase_get_isEmpty.
         return false;
       }
       InlineStringIsEmptyGetter(call);
       return true;
     case MethodRecognizer::kFloat32x4ShuffleX:
     case MethodRecognizer::kFloat32x4ShuffleY:
     case MethodRecognizer::kFloat32x4ShuffleZ:
     case MethodRecognizer::kFloat32x4ShuffleW:
+    case MethodRecognizer::kFloat32x4GetSignMask:
       if (!ic_data.HasReceiverClassId(kFloat32x4Cid) ||
           !ic_data.HasOneTarget()) {
         return false;
       }
       return InlineFloat32x4Getter(call, recognized_kind);
     case MethodRecognizer::kUint32x4GetFlagX:
     case MethodRecognizer::kUint32x4GetFlagY:
     case MethodRecognizer::kUint32x4GetFlagZ:
     case MethodRecognizer::kUint32x4GetFlagW: {
       if (!ic_data.HasReceiverClassId(kUint32x4Cid) ||
@@ skipping 4800 matching lines @@
     Float32x4ConstructorInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4Shuffle(Float32x4ShuffleInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitFloat32x4GetSignMask(
+    Float32x4GetSignMaskInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitFloat32x4Zero(Float32x4ZeroInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4Splat(Float32x4SplatInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
@@ skipping 1012 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart