mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
11f0ff6e32
For years, optimizer engineers have been hitting a common bug caused by passes assuming all SILValues have a parent function only to be surprised by SILUndef. Generally we see SILUndef not that often so we see this come up later in testing. This patch eliminates that problem by making SILUndef uniqued at the function level instead of the module level. This ensures that it makes sense for SILUndef to have a parent function, eliminating this possibility since we can define an API to get its parent function. rdar://123484595
126 lines
3.6 KiB
C++
126 lines
3.6 KiB
C++
//===--- OwnershipPhiOperand.h --------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_SILOPTIMIZER_SEMANTICARC_OWNERSHIPPHIOPERAND_H
|
|
#define SWIFT_SILOPTIMIZER_SEMANTICARC_OWNERSHIPPHIOPERAND_H
|
|
|
|
#include "swift/Basic/STLExtras.h"
|
|
#include "swift/SIL/SILArgument.h"
|
|
#include "swift/SIL/SILBasicBlock.h"
|
|
#include "swift/SIL/SILInstruction.h"
|
|
#include "swift/SIL/SILUndef.h"
|
|
#include "swift/SIL/SILValue.h"
|
|
|
|
namespace swift {
|
|
namespace semanticarc {
|
|
|
|
/// The operand of a "phi" in the induced ownership graph of a def-use graph.
|
|
///
|
|
/// Some examples: br, struct, tuple.
|
|
class LLVM_LIBRARY_VISIBILITY OwnershipPhiOperand {
|
|
public:
|
|
enum Kind {
|
|
Branch,
|
|
Struct,
|
|
Tuple,
|
|
};
|
|
|
|
private:
|
|
Operand *op;
|
|
|
|
OwnershipPhiOperand(Operand *op) : op(op) {}
|
|
|
|
public:
|
|
static std::optional<OwnershipPhiOperand> get(const Operand *op) {
|
|
switch (op->getUser()->getKind()) {
|
|
case SILInstructionKind::BranchInst:
|
|
case SILInstructionKind::StructInst:
|
|
case SILInstructionKind::TupleInst:
|
|
return {{const_cast<Operand *>(op)}};
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
Kind getKind() const {
|
|
switch (op->getUser()->getKind()) {
|
|
case SILInstructionKind::BranchInst:
|
|
return Kind::Branch;
|
|
case SILInstructionKind::StructInst:
|
|
return Kind::Struct;
|
|
case SILInstructionKind::TupleInst:
|
|
return Kind::Tuple;
|
|
default:
|
|
llvm_unreachable("unhandled case?!");
|
|
}
|
|
}
|
|
|
|
operator const Operand *() const { return op; }
|
|
operator Operand *() { return op; }
|
|
|
|
Operand *getOperand() const { return op; }
|
|
SILValue getValue() const { return op->get(); }
|
|
SILType getType() const { return op->get()->getType(); }
|
|
|
|
unsigned getOperandNumber() const { return op->getOperandNumber(); }
|
|
|
|
void markUndef() & { op->set(SILUndef::get(getValue())); }
|
|
|
|
SILInstruction *getInst() const { return op->getUser(); }
|
|
|
|
/// Return true if this phi consumes a borrow.
|
|
///
|
|
/// If so, we may need to insert an extra begin_borrow to balance the +1 when
|
|
/// converting owned ownership phis to guaranteed ownership phis.
|
|
bool isGuaranteedConsuming() const {
|
|
switch (getKind()) {
|
|
case Kind::Branch:
|
|
return true;
|
|
case Kind::Tuple:
|
|
case Kind::Struct:
|
|
return false;
|
|
}
|
|
llvm_unreachable("unhandled operand kind!");
|
|
}
|
|
|
|
bool operator<(const OwnershipPhiOperand &other) const {
|
|
return op < other.op;
|
|
}
|
|
|
|
bool operator==(const OwnershipPhiOperand &other) const {
|
|
return op == other.op;
|
|
}
|
|
|
|
bool visitResults(function_ref<bool(SILValue)> visitor) const {
|
|
switch (getKind()) {
|
|
case Kind::Struct:
|
|
return visitor(cast<StructInst>(getInst()));
|
|
case Kind::Tuple:
|
|
return visitor(cast<TupleInst>(getInst()));
|
|
case Kind::Branch: {
|
|
auto *br = cast<BranchInst>(getInst());
|
|
unsigned opNum = getOperandNumber();
|
|
return llvm::all_of(
|
|
br->getSuccessorBlocks(), [&](SILBasicBlock *succBlock) {
|
|
return visitor(succBlock->getSILPhiArguments()[opNum]);
|
|
});
|
|
}
|
|
}
|
|
llvm_unreachable("unhandled operand kind!");
|
|
}
|
|
};
|
|
|
|
} // namespace semanticarc
|
|
} // namespace swift
|
|
|
|
#endif // SWIFT_SILOPTIMIZER_SEMANTICARC_OWNERSHIPPHIOPERAND_H
|