[wasm] Reuse constrained input for same vreg

src/compiler/register-allocator.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/adapters.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 1687 matching lines @@
 void ConstraintBuilder::MeetConstraintsAfter(int instr_index) {
   Instruction* first = code()->InstructionAt(instr_index);
   // Handle fixed temporaries.
   for (size_t i = 0; i < first->TempCount(); i++) {
     UnallocatedOperand* temp = UnallocatedOperand::cast(first->TempAt(i));
     if (temp->HasFixedPolicy()) AllocateFixed(temp, instr_index, false);
   }
   // Handle constant/fixed output operands.
   for (size_t i = 0; i < first->OutputCount(); i++) {
     InstructionOperand* output = first->OutputAt(i);
+    if (output->IsAllocated()) continue;
     if (output->IsConstant()) {
       int output_vreg = ConstantOperand::cast(output)->virtual_register();
       TopLevelLiveRange* range = data()->GetOrCreateLiveRangeFor(output_vreg);
       range->SetSpillStartIndex(instr_index + 1);
       range->SetSpillOperand(output);
       continue;
     }
     UnallocatedOperand* first_output = UnallocatedOperand::cast(output);
     TopLevelLiveRange* range =
         data()->GetOrCreateLiveRangeFor(first_output->virtual_register());
@@ skipping 26 matching lines @@
       range->RecordSpillLocation(allocation_zone(), instr_index + 1,
                                  first_output);
       range->SetSpillStartIndex(instr_index + 1);
     }
   }
 }
 
 
 void ConstraintBuilder::MeetConstraintsBefore(int instr_index) {
   Instruction* second = code()->InstructionAt(instr_index);
+  ZoneMap<int, InstructionOperand> constraints(allocation_zone());
+
   // Handle fixed input operands of second instruction.
-  for (size_t i = 0; i < second->InputCount(); i++) {
+  for (size_t i = 0; i < second->InputCount(); ++i) {
     InstructionOperand* input = second->InputAt(i);
     if (input->IsImmediate() || input->IsExplicit()) {
       continue;  // Ignore immediates and explicitly reserved registers.
     }
     UnallocatedOperand* cur_input = UnallocatedOperand::cast(input);
     if (cur_input->HasFixedPolicy()) {
       int input_vreg = cur_input->virtual_register();
       UnallocatedOperand input_copy(UnallocatedOperand::ANY, input_vreg);
       bool is_tagged = code()->IsReference(input_vreg);
       AllocateFixed(cur_input, instr_index, is_tagged);
+      // TODO(mtrofin): refactor AllocateFixed, its behavior is
+      // not the most maintainable: cur_input is mutated.
+      if (cur_input->IsAnyRegister()) {
+        // It may be that the vreg is constrained to be in different registers.
+        // We just want one of them for the other potential non-fixed register
+        // uses.
+        constraints.insert(std::make_pair(input_vreg, *cur_input));
+      }
       data()->AddGapMove(instr_index, Instruction::END, input_copy, *cur_input);
     }
   }
   // Handle "output same as input" for second instruction.
-  for (size_t i = 0; i < second->OutputCount(); i++) {
+  for (size_t i = 0; i < second->OutputCount(); ++i) {
     InstructionOperand* output = second->OutputAt(i);
     if (!output->IsUnallocated()) continue;
     UnallocatedOperand* second_output = UnallocatedOperand::cast(output);
     if (!second_output->HasSameAsInputPolicy()) continue;
     DCHECK(i == 0);  // Only valid for first output.
     UnallocatedOperand* cur_input =
         UnallocatedOperand::cast(second->InputAt(0));
     int output_vreg = second_output->virtual_register();
     int input_vreg = cur_input->virtual_register();
-    UnallocatedOperand input_copy(UnallocatedOperand::ANY, input_vreg);
-    cur_input->set_virtual_register(second_output->virtual_register());
-    MoveOperands* gap_move = data()->AddGapMove(instr_index, Instruction::END,
-                                                input_copy, *cur_input);
-    if (code()->IsReference(input_vreg) && !code()->IsReference(output_vreg)) {
-      if (second->HasReferenceMap()) {
-        RegisterAllocationData::DelayedReference delayed_reference = {
-            second->reference_map(), &gap_move->source()};
-        data()->delayed_references().push_back(delayed_reference);
+    if (constraints.count(input_vreg) > 0) {
+      InstructionOperand reg_operand = constraints[input_vreg];
+      InstructionOperand::ReplaceWith(second_output, &reg_operand);
+      if (data()->code()->instructions().size() >
+          static_cast<size_t>(instr_index) + 1) {
+        UnallocatedOperand new_output_op(UnallocatedOperand::ANY, output_vreg);
+        data()->AddGapMove(instr_index + 1, Instruction::START, reg_operand,
+                           new_output_op);
+        TopLevelLiveRange* range = data()->GetOrCreateLiveRangeFor(output_vreg);
+        range->RecordSpillLocation(allocation_zone(), instr_index + 1,
+                                   second_output);
+        range->SetSpillStartIndex(instr_index + 1);
       }
-    } else if (!code()->IsReference(input_vreg) &&
-               code()->IsReference(output_vreg)) {
-      // The input is assumed to immediately have a tagged representation,
-      // before the pointer map can be used. I.e. the pointer map at the
-      // instruction will include the output operand (whose value at the
-      // beginning of the instruction is equal to the input operand). If
-      // this is not desired, then the pointer map at this instruction needs
-      // to be adjusted manually.
+    } else {
+      UnallocatedOperand input_copy(UnallocatedOperand::ANY, input_vreg);
+      cur_input->set_virtual_register(second_output->virtual_register());
+      MoveOperands* gap_move = data()->AddGapMove(instr_index, Instruction::END,
+                                                  input_copy, *cur_input);
+      if (code()->IsReference(input_vreg) &&
+          !code()->IsReference(output_vreg)) {
+        if (second->HasReferenceMap()) {
+          RegisterAllocationData::DelayedReference delayed_reference = {
+              second->reference_map(), &gap_move->source()};
+          data()->delayed_references().push_back(delayed_reference);
+        }
+      } else if (!code()->IsReference(input_vreg) &&
+                 code()->IsReference(output_vreg)) {
+        // The input is assumed to immediately have a tagged representation,
+        // before the pointer map can be used. I.e. the pointer map at the
+        // instruction will include the output operand (whose value at the
+        // beginning of the instruction is equal to the input operand). If
+        // this is not desired, then the pointer map at this instruction needs
+        // to be adjusted manually.
+      }
+    }
+  }
+
+  for (size_t i = 0; i < second->InputCount(); ++i) {
+    InstructionOperand* input = second->InputAt(i);
+    if (!input->IsUnallocated()) continue;
+    UnallocatedOperand* cur_input = UnallocatedOperand::cast(input);
+    if (cur_input->HasFixedPolicy() || cur_input->HasSlotPolicy()) {
+      continue;
+    }
+    int vreg = cur_input->virtual_register();
+    if (constraints.count(vreg) > 0) {
+      InstructionOperand::ReplaceWith(input, &constraints.at(vreg));
     }
   }
 }
 
 
 void ConstraintBuilder::ResolvePhis() {
   // Process the blocks in reverse order.
   for (InstructionBlock* block : base::Reversed(code()->instruction_blocks())) {
     ResolvePhis(block);
   }
@@ skipping 2202 matching lines @@
         }
       }
     }
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8