Rebase of partial ia32 implementation of optimized try/catch (started by Kevin Millikin, continued …

src/ia32/lithium-ia32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 969 matching lines @@
 }
 
 
 LEnvironment* LChunkBuilder::CreateEnvironment(
     HEnvironment* hydrogen_env,
     int* argument_index_accumulator) {
   if (hydrogen_env == NULL) return NULL;
 
   LEnvironment* outer =
       CreateEnvironment(hydrogen_env->outer(), argument_index_accumulator);
+#if DEBUG
   BailoutId ast_id = hydrogen_env->ast_id();
   ASSERT(!ast_id.IsNone() ||
          hydrogen_env->frame_type() != JS_FUNCTION);
+#endif
   int value_count = hydrogen_env->length() - hydrogen_env->specials_count();
   LEnvironment* result =
-      new(zone()) LEnvironment(hydrogen_env->closure(),
-                               hydrogen_env->frame_type(),
-                               ast_id,
-                               hydrogen_env->parameter_count(),
+      new(zone()) LEnvironment(hydrogen_env,
                                argument_count_,
                                value_count,
                                outer,
                                hydrogen_env->entry(),
                                zone());
+
   bool needs_arguments_object_materialization = false;
   int argument_index = *argument_index_accumulator;
   for (int i = 0; i < hydrogen_env->length(); ++i) {
     if (hydrogen_env->is_special_index(i)) continue;
 
     HValue* value = hydrogen_env->values()->at(i);
     LOperand* op = NULL;
     if (value->IsArgumentsObject()) {
       needs_arguments_object_materialization = true;
       op = NULL;
@@ skipping 1721 matching lines @@
     return MarkAsCall(new(zone()) LStackCheck(context), instr);
   } else {
     ASSERT(instr->is_backwards_branch());
     LOperand* context = UseAny(instr->context());
     return AssignEnvironment(
         AssignPointerMap(new(zone()) LStackCheck(context)));
   }
 }
 
 
+LInstruction* LChunkBuilder::DoEnterTry(HEnterTry* instr) {
+  current_block_->last_environment()->AddExceptionHandler();
+  return new(zone()) LEnterTry;
+}
+
+
+LInstruction* LChunkBuilder::DoLeaveTry(HLeaveTry* instr) {
+  current_block_->last_environment()->RemoveExceptionHandler();
+  return new(zone()) LLeaveTry;
+}
+
+
 LInstruction* LChunkBuilder::DoEnterInlined(HEnterInlined* instr) {
   HEnvironment* outer = current_block_->last_environment();
   HConstant* undefined = graph()->GetConstantUndefined();
   HEnvironment* inner = outer->CopyForInlining(instr->closure(),
                                                instr->arguments_count(),
                                                instr->function(),
                                                undefined,
                                                instr->inlining_kind(),
                                                instr->undefined_receiver());
   // Only replay binding of arguments object if it wasn't removed from graph.
@@ skipping 59 matching lines @@
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseTempRegister(instr->index());
   return DefineSameAsFirst(new(zone()) LLoadFieldByIndex(object, index));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32