Optimize functions containing try-catch.

runtime/vm/flow_graph_compiler_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 628 matching lines @@
       GuardFieldInstr* guard = instr->AsGuardField();
       AddCurrentDescriptor(PcDescriptors::kDeopt,
                            guard->deopt_id(),
                            Scanner::kDummyTokenIndex);
     } else if (instr->CanBeDeoptimizationTarget()) {
       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());
+  }
+}
+
+
+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;
+  for (; i < flow_graph().num_non_copied_params(); ++i) {
+    if ((*idefs)[i]->IsConstant()) continue;  // common constants

[Kevin Millikin (Google), 2013/05/08 11:42:00]

Common constants.

[Florian Schneider, 2013/05/08 17:10:55]

Done.

+    Location loc = env->LocationAt(i);
+    const intptr_t index = flow_graph().num_non_copied_params() - i;
+    Address dest(EBP, (kLastParamSlotIndex + index - 1) * kWordSize);

[Kevin Millikin (Google), 2013/05/08 11:42:00]

I don't like the name "index" --- it's not what I think of as the index (it's
the 1-based parameter index when numbered in reverse?) and that makes it
confusing.

Since the subexpression is

kLastParamSlotIndex + flow_graph().num_non_copied_params() - i - 1

you could refactor out the unchanging parts and write:

const intptr_t base =
    kLastParamSlotIndex + flow_graph().num_non_copied_params() - 1;
Address dest(EBP, (base - i) * kWordSize);

[Florian Schneider, 2013/05/08 17:10:55]

Done.

+    if (loc.IsConstant()) {
+      if (!push_emitted) {
+        __ pushl(EAX);
+        push_emitted = true;
+      }
+      __ LoadObject(EAX, loc.constant());
+      __ movl(dest, EAX);
+    } else if (loc.IsRegister()) {
+      __ movl(dest, loc.reg());

[Kevin Millikin (Google), 2013/05/08 11:42:00]

Is this safe?  What if loc.reg() is EAX and push_emitted is true?  In that case
don't you want

movl(EAX, Address(ESP, 0));
movl(dest, EAX);

[Florian Schneider, 2013/05/08 17:10:55]

Done. Yes, of course. That is a bug. I wonder why no test hit that case.

+    } else {
+      Address src = loc.ToStackSlotAddress();
+      if (!src.Equals(dest)) {
+        if (!push_emitted) {
+          __ pushl(EAX);
+          push_emitted = true;
+        }
+        __ movl(EAX, src);
+        __ movl(dest, EAX);
+      }
+    }
+  }
+  // Process locals. Skip exception_var and stacktrace_var.
+  CatchEntryInstr* catch_entry = catch_block->next()->AsCatchEntry();
+  intptr_t nncp = flow_graph_.num_non_copied_params();

[Kevin Millikin (Google), 2013/05/08 11:42:00]

Yucky name.  What about:

intptr_t base =
    kFirstLocalSlotIndex + flow_graph_.num_non_copied_params();
intptr_t ex_idx = base - catch_entry->exception_var().index();
intptr_t st_idx = base - catch_entry->stacktrace_var().index();

[Florian Schneider, 2013/05/08 17:10:55]

Done.

+  intptr_t ex_idx =
+      kFirstLocalSlotIndex - catch_entry->exception_var().index() + nncp;
+  intptr_t st_idx =
+      kFirstLocalSlotIndex - catch_entry->stacktrace_var().index() + nncp;
+  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);
+    const intptr_t index =  i - flow_graph().num_non_copied_params();
+    Address dest(EBP, (kFirstLocalSlotIndex - index) * kWordSize);

[Kevin Millikin (Google), 2013/05/08 11:42:00]

If you introduce 'base' as suggested above, this becomes

Address dest(EBP, (base - i) * kWordSize);

[Florian Schneider, 2013/05/08 17:10:55]

Done.

+    if (loc.IsConstant()) {

[Kevin Millikin (Google), 2013/05/08 11:42:00]

Introduce a function that takes an Address and in-out pointer to push_emitted,
and emits the move code.

[Florian Schneider, 2013/05/08 17:10:55]

Done.

+      if (!push_emitted) {
+        __ pushl(EAX);
+        push_emitted = true;
+      }
+      __ LoadObject(EAX, loc.constant());
+      __ movl(dest, EAX);
+    } else if (loc.IsRegister()) {
+        __ movl(dest, loc.reg());
+    } else {
+      Address src = loc.ToStackSlotAddress();
+      if (!src.Equals(dest)) {
+        if (!push_emitted) {
+          __ pushl(EAX);
+          push_emitted = true;
+        }
+        __ movl(EAX, src);
+        __ movl(dest, EAX);
+      }
+    }
+    // Update safepoint bitmap to indicate that the target location
+    // now contains a pointer.
+    instr->locs()->stack_bitmap()->Set(index, true);
+  }
+  if (push_emitted) {
+    __ popl(EAX);
   }
 }
 
 
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   if (is_optimizing()) return;
   Definition* defn = instr->AsDefinition();
   if ((defn != NULL) && defn->is_used()) {
     __ pushl(defn->locs()->out().reg());
   }
@@ skipping 272 matching lines @@
           Immediate(FLAG_optimization_counter_threshold));
       ASSERT(function_reg == EDI);
       __ j(GREATER_EQUAL, &StubCode::OptimizeFunctionLabel());
     }
   } else {
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
   }
   __ Comment("Enter frame");
-  __ EnterDartFrame((StackSize() * kWordSize));
+  __ EnterDartFrame(StackSize() * kWordSize);
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
   if (TryIntrinsify()) {
     // Although this intrinsified code will never be patched, it must satisfy
     // CodePatcher::CodeIsPatchable, which verifies that this code has a minimum
     // code size.
     __ int3();
@@ skipping 829 matching lines @@
   __ movups(reg, Address(ESP, 0));
   __ addl(ESP, Immediate(kFpuRegisterSize));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32