Optimize functions containing try-catch on ARM.

runtime/vm/flow_graph_compiler_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 704 matching lines @@
       AddCurrentDescriptor(PcDescriptors::kDeopt,
                            assert->deopt_id(),
                            assert->token_pos());
     } else if (instr->IsGuardField() ||
                instr->CanBecomeDeoptimizationTarget()) {
       AddCurrentDescriptor(PcDescriptors::kDeopt,
                            instr->deopt_id(),
                            Scanner::kDummyTokenIndex);
     }
     AllocateRegistersLocally(instr);
+  } else if (instr->MayThrow()  &&
+             (CurrentTryIndex() != CatchClauseNode::kInvalidTryIndex)) {
+    // Optimized try-block: Sync locals to fixed stack locations.
+    EmitTrySync(instr, CurrentTryIndex());
+  }
+}
+
+
+// TODO(regis): Pass an offset instead of an Address to avoid addressing
+// mode restrictions and remove Operand::Equals() on IA32/X64 and
+// Address::Equals() on ARM/MIPS.
+void FlowGraphCompiler::EmitTrySyncMove(Address dest,
+                                        Location loc,
+                                        bool* push_emitted) {
+  if (loc.IsConstant()) {
+    if (!*push_emitted) {
+      __ Push(R0);
+      *push_emitted = true;
+    }
+    __ LoadObject(R0, loc.constant());
+    __ str(R0, dest);
+  } else if (loc.IsRegister()) {
+    if (*push_emitted && (loc.reg() == R0)) {
+      __ ldr(R0, Address(SP, 0));
+      __ str(R0, dest);
+    } else {
+      __ str(loc.reg(), dest);
+    }
+  } else {
+    Address src = loc.ToStackSlotAddress();
+    if (!src.Equals(dest)) {
+      if (!*push_emitted) {
+        __ Push(R0);
+        *push_emitted = true;
+      }
+      __ ldr(R0, src);
+      __ str(R0, dest);
+    }
+  }
+}
+
+
+void FlowGraphCompiler::EmitTrySync(Instruction* instr, intptr_t try_index) {
+  ASSERT(is_optimizing());
+  Environment* env = instr->env();
+  CatchBlockEntryInstr* catch_block =
+      flow_graph().graph_entry()->GetCatchEntry(try_index);
+  const GrowableArray<Definition*>* idefs = catch_block->initial_definitions();
+  // Parameters.
+  intptr_t i = 0;
+  bool push_emitted = false;
+  const intptr_t num_non_copied_params = flow_graph().num_non_copied_params();
+  const intptr_t param_base =
+      kParamEndSlotFromFp + num_non_copied_params;
+  for (; i < num_non_copied_params; ++i) {
+    if ((*idefs)[i]->IsConstant()) continue;  // Common constants
+    Location loc = env->LocationAt(i);
+    Address dest(FP, (param_base - i) * kWordSize);
+    EmitTrySyncMove(dest, loc, &push_emitted);
+  }
+
+  // Process locals. Skip exception_var and stacktrace_var.
+  CatchEntryInstr* catch_entry = catch_block->next()->AsCatchEntry();
+  intptr_t local_base = kFirstLocalSlotFromFp + num_non_copied_params;
+  intptr_t ex_idx = local_base - catch_entry->exception_var().index();
+  intptr_t st_idx = local_base - catch_entry->stacktrace_var().index();
+  for (; i < flow_graph().variable_count(); ++i) {
+    if (i == ex_idx || i == st_idx) continue;
+    if ((*idefs)[i]->IsConstant()) continue;
+    Location loc = env->LocationAt(i);
+    Address dest(FP, (local_base - i) * kWordSize);
+    EmitTrySyncMove(dest, loc, &push_emitted);
+    // Update safepoint bitmap to indicate that the target location
+    // now contains a pointer.
+    instr->locs()->stack_bitmap()->Set(i - num_non_copied_params, true);
+  }
+  if (push_emitted) {
+    __ Pop(R0);
   }
 }
 
 
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   if (is_optimizing()) return;
   Definition* defn = instr->AsDefinition();
   if ((defn != NULL) && defn->is_used()) {
     __ Push(defn->locs()->out().reg());
   }
@@ skipping 266 matching lines @@
       __ CompareImmediate(R7, FLAG_optimization_counter_threshold);
       ASSERT(function_reg == R6);
       __ Branch(&StubCode::OptimizeFunctionLabel(), GE);
     }
   } else {
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
   }
   __ Comment("Enter frame");
-  __ EnterDartFrame((StackSize() * kWordSize));
+  __ EnterDartFrame(StackSize() * kWordSize);
 }
 
 
 // Input parameters:
 //   LR: return address.
 //   SP: address of last argument.
 //   FP: caller's frame pointer.
 //   PP: caller's pool pointer.
 //   R5: ic-data.
 //   R4: arguments descriptor array.
@@ skipping 739 matching lines @@
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   __ vldrd(reg, Address(SP, kDoubleSize, Address::PostIndex));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM