Generate some intrinsics using our IR.

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 80 matching lines @@
       exception_handlers_list_(NULL),
       pc_descriptors_list_(NULL),
       stackmap_table_builder_(
           is_optimizing ? new StackmapTableBuilder() : NULL),
       block_info_(block_order_.length()),
       deopt_infos_(),
       static_calls_target_table_(GrowableObjectArray::ZoneHandle(
           GrowableObjectArray::New())),
       is_optimizing_(is_optimizing),
       may_reoptimize_(false),
+      intrinsic_mode_(false),
       double_class_(Class::ZoneHandle(
           isolate_->object_store()->double_class())),
       mint_class_(Class::ZoneHandle(
           isolate_->object_store()->mint_class())),
       float32x4_class_(Class::ZoneHandle(
           isolate_->object_store()->float32x4_class())),
       float64x2_class_(Class::ZoneHandle(
           isolate_->object_store()->float64x2_class())),
       int32x4_class_(Class::ZoneHandle(
           isolate_->object_store()->int32x4_class())),
@@ skipping 429 matching lines @@
   ASSERT(Code::kSCallTableFunctionEntry == 1);
   static_calls_target_table_.Add(func);
   ASSERT(Code::kSCallTableCodeEntry == 2);
   static_calls_target_table_.Add(Code::Handle());
 }
 
 
 void FlowGraphCompiler::AddDeoptIndexAtCall(intptr_t deopt_id,
                                             intptr_t token_pos) {
   ASSERT(is_optimizing());
+  ASSERT(!intrinsic_mode());
   CompilerDeoptInfo* info =
       new CompilerDeoptInfo(deopt_id,
                             ICData::kDeoptAtCall,
                             pending_deoptimization_env_);
   info->set_pc_offset(assembler()->CodeSize());
   deopt_infos_.Add(info);
 }
 
 
 // This function must be in sync with FlowGraphCompiler::SaveLiveRegisters
@@ skipping 160 matching lines @@
                                                    cpu_reg_slots);
       }
     }
   }
   return env;
 }
 
 
 Label* FlowGraphCompiler::AddDeoptStub(intptr_t deopt_id,
                                        ICData::DeoptReasonId reason) {
+  if (intrinsic_mode()) return &intrinsic_deopt_label_;

[srdjan, 2014/09/02 18:48:21]

This feels fragile as we must guaranteed that the lifetime of FlowGraphCompiler
exceeds the lifetime of the new 'owner' of the  intrinsic_deopt_label_.

[Florian Schneider, 2014/09/02 21:03:20]

Can you elaborate? There is only one instance of FlowGraphCompiler. It is either
in intrinsic mode, or in normal mode. Intrinsic mode is active before generating
the normal body (slow-path) of the function. When it is active, all
deopt-branches go to this label instead of a real deopt-stub.

[srdjan, 2014/09/08 17:34:06]

I was mainly worried that the lifetime of a FlowGraphCompiler instance may be
shorter than the use of the label. Looking at the code again, my worry is
probably unnecessary

+
   ASSERT(is_optimizing_);
   CompilerDeoptInfoWithStub* stub =
       new CompilerDeoptInfoWithStub(deopt_id,
                                     reason,
                                     pending_deoptimization_env_);
   deopt_infos_.Add(stub);
   return stub->entry_label();
 }
 
 
@@ skipping 108 matching lines @@
       ASSERT(sequence_node.NodeAt(0)->IsStoreInstanceFieldNode());
       ASSERT(sequence_node.NodeAt(1)->IsReturnNode());
       const StoreInstanceFieldNode& store_node =
           *sequence_node.NodeAt(0)->AsStoreInstanceFieldNode();
       if (store_node.field().guarded_cid() == kDynamicCid) {
         GenerateInlinedSetter(store_node.field().Offset());
         return;
       }
     }
   }
-  // Even if an intrinsified version of the function was successfully
-  // generated, it may fall through to the non-intrinsified method body.
-  Intrinsifier::Intrinsify(parsed_function().function(), assembler());
+
+  EnterIntrinsicMode();
+
+  Intrinsifier::Intrinsify(parsed_function(), this);
+
+  ExitIntrinsicMode();
+  // "Deoptimization" from intrinsic continues here.

[srdjan, 2014/09/02 18:48:21]

We do not deoptimize, this is actually the slow-path, isn't it?

[Florian Schneider, 2014/09/02 21:03:20]

That's why it's in quotes. Intrinsic code uses the same IL instructions as the
optimizing compiler. Check instructions that deoptimize in regular optimized
code just branch to here.

+  ASSERT(!intrinsic_deopt_label_.IsBound());
+  assembler()->Bind(&intrinsic_deopt_label_);
 }
 
 
 void FlowGraphCompiler::GenerateInstanceCall(
     intptr_t deopt_id,
     intptr_t token_pos,
     intptr_t argument_count,
     LocationSummary* locs,
     const ICData& ic_data) {
   ASSERT(!ic_data.IsNull());
@@ skipping 412 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 
 intptr_t ParallelMoveResolver::AllocateScratchRegister(
     Location::Kind kind,
-    intptr_t blocked,
+    uword blocked_mask,
     intptr_t first_free_register,
     intptr_t last_free_register,
     bool* spilled) {
+  COMPILE_ASSERT(static_cast<intptr_t>(sizeof(blocked_mask)) * kBitsPerByte >=
+                 kNumberOfFpuRegisters);
+  COMPILE_ASSERT(static_cast<intptr_t>(sizeof(blocked_mask)) * kBitsPerByte >=
+                 kNumberOfCpuRegisters);
   intptr_t scratch = -1;
   for (intptr_t reg = first_free_register; reg <= last_free_register; reg++) {
-    if ((blocked != reg) &&
+    if ((((1u << reg) & blocked_mask) == 0) &&
         IsScratchLocation(Location::MachineRegisterLocation(kind, reg))) {
       scratch = reg;
       break;
     }
   }
 
   if (scratch == -1) {
     *spilled = true;
     for (intptr_t reg = first_free_register; reg <= last_free_register; reg++) {
-      if (blocked != reg) {
+      if (((1u << reg) & blocked_mask) == 0) {
         scratch = reg;
         break;
       }
     }
   } else {
     *spilled = false;
   }
 
   return scratch;
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::ScratchFpuRegisterScope(
     ParallelMoveResolver* resolver, FpuRegister blocked)
     : resolver_(resolver),
       reg_(kNoFpuRegister),
       spilled_(false) {
   reg_ = static_cast<FpuRegister>(
       resolver_->AllocateScratchRegister(Location::kFpuRegister,
-                                         blocked,
+                                         1u << blocked,
                                          0,
                                          kNumberOfFpuRegisters - 1,
                                          &spilled_));
 
   if (spilled_) {
     resolver->SpillFpuScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::~ScratchFpuRegisterScope() {
   if (spilled_) {
     resolver_->RestoreFpuScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchRegisterScope::ScratchRegisterScope(
     ParallelMoveResolver* resolver, Register blocked)
     : resolver_(resolver),
       reg_(kNoRegister),
       spilled_(false) {
+  uword blocked_mask = 1u << blocked;
+  if (resolver->compiler_->intrinsic_mode()) {
+    // Block additional registers that must be preserved for intrinsics.
+    blocked_mask |= 1u << ICREG;
+    blocked_mask |= 1u << ARGS_DESC_REG;
+  }
   reg_ = static_cast<Register>(
       resolver_->AllocateScratchRegister(Location::kRegister,
-                                         blocked,
+                                         1u << blocked,
                                          kFirstFreeCpuRegister,
                                          kLastFreeCpuRegister,
                                          &spilled_));
 
   if (spilled_) {
     resolver->SpillScratch(reg_);
   }
 }
 
 
@@ skipping 80 matching lines @@
     threshold = FLAG_optimization_counter_scale * basic_blocks +
         FLAG_min_optimization_counter_threshold;
     if (threshold > FLAG_optimization_counter_threshold) {
       threshold = FLAG_optimization_counter_threshold;
     }
   }
   return threshold;
 }
 
 }  // namespace dart