// Copyright (c) 2019, the R8 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.

package com.android.tools.r8.ir.optimize;

import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.Assume;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.ir.code.Value;
import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Set;

/**
 * When we have Assume instructions we generally verify that the Assume instructions contribute with
 * non-trivial information to the IR (e.g., the dynamic type should be more precise than the static
 * type).
 *
 * <p>Therefore, when this property may no longer hold for an Assume instruction, we need to remove
 * it.
 *
 * <p>This class is a helper class to remove these instructions. Unlike {@link
 * CodeRewriter#removeAssumeInstructions} this class does not unconditionally remove all Assume
 * instructions.
 */
public class AssumeRemover {

  private final AppView<?> appView;
  private final IRCode code;

  private final Set<Value> affectedValues;
  private final Set<Assume> assumeInstructionsToRemove = Sets.newIdentityHashSet();

  private boolean mayHaveIntroducedTrivialPhi = false;

  public AssumeRemover(AppView<?> appView, IRCode code) {
    this(appView, code, Sets.newIdentityHashSet());
  }

  public AssumeRemover(AppView<?> appView, IRCode code, Set<Value> affectedValues) {
    this.appView = appView;
    this.code = code;
    this.affectedValues = affectedValues;
  }

  public Set<Value> getAffectedValues() {
    return affectedValues;
  }

  public boolean mayHaveIntroducedTrivialPhi() {
    return mayHaveIntroducedTrivialPhi;
  }

  public void markAssumeDynamicTypeUsersForRemoval(Value value) {
    for (Instruction user : value.aliasedUsers()) {
      if (user.isAssume()) {
        Assume assumeInstruction = user.asAssume();
        assumeInstruction.unsetDynamicTypeAssumption();
        if (!assumeInstruction.hasNonNullAssumption()) {
          markForRemoval(assumeInstruction);
        }
      }
    }
  }

  public void markUnusedAssumeValuesForRemoval(Collection<Value> values) {
    for (Value value : values) {
      if (value.isDefinedByInstructionSatisfying(Instruction::isAssume) && !value.hasAnyUsers()) {
        markForRemoval(value.getDefinition().asAssume());
      }
    }
  }

  private void markForRemoval(Assume assumeInstruction) {
    assumeInstructionsToRemove.add(assumeInstruction);
  }

  public void removeIfMarked(
      Assume assumeInstruction, InstructionListIterator instructionIterator) {
    if (assumeInstructionsToRemove.remove(assumeInstruction)) {
      Value inValue = assumeInstruction.src();
      Value outValue = assumeInstruction.outValue();

      // Check if we need to run the type analysis for the affected values of the out-value.
      if (!outValue.getType().equals(inValue.getType())) {
        affectedValues.addAll(outValue.affectedValues());
      }

      if (outValue.hasPhiUsers()) {
        mayHaveIntroducedTrivialPhi = true;
      }

      outValue.replaceUsers(inValue);
      instructionIterator.removeOrReplaceByDebugLocalRead();
    }
  }

  public AssumeRemover removeMarkedInstructions() {
    return removeMarkedInstructions(null);
  }

  public AssumeRemover removeMarkedInstructions(Set<BasicBlock> blocksToBeRemoved) {
    if (!assumeInstructionsToRemove.isEmpty()) {
      for (BasicBlock block : code.blocks) {
        if (blocksToBeRemoved != null && blocksToBeRemoved.contains(block)) {
          continue;
        }
        InstructionListIterator instructionIterator = block.listIterator(code);
        while (instructionIterator.hasNext()) {
          Instruction instruction = instructionIterator.next();
          if (instruction.isAssume()) {
            removeIfMarked(instruction.asAssume(), instructionIterator);
          }
        }
      }
    }
    return this;
  }

  public void finish() {
    if (!affectedValues.isEmpty()) {
      new TypeAnalysis(appView).narrowing(affectedValues);
    }
  }
}