return TRI.getSpillSize(*RC);
}
+namespace {
// Cache used frame indexes during statepoint re-write to re-use them in
// processing next statepoint instruction.
// Two strategies. One is to preserve the size of spill slot while another one
return true;
}
};
+} // namespace
bool FixupStatepointCallerSaved::runOnMachineFunction(MachineFunction &MF) {
if (skipFunction(MF.getFunction()))
PotentialMIsForDebugLocs.insert(&MI);
}
-bool irTranslatorNeverAddsLocations(unsigned Opcode) {
+static bool irTranslatorNeverAddsLocations(unsigned Opcode) {
switch (Opcode) {
default:
return false;
}
// Return true if the given intrinsic is a gather or scatter
-bool isGatherScatter(IntrinsicInst *IntInst) {
+static bool isGatherScatter(IntrinsicInst *IntInst) {
if (IntInst == nullptr)
return false;
unsigned IntrinsicID = IntInst->getIntrinsicID();
// Check whether all usages of this instruction are as offsets of
// gathers/scatters or simple arithmetics only used by gathers/scatters
-bool hasAllGatScatUsers(Instruction *I) {
+static bool hasAllGatScatUsers(Instruction *I) {
if (I->hasNUses(0)) {
return false;
}
return S;
}
+namespace {
struct AAMemoryLocationImpl : public AAMemoryLocation {
AAMemoryLocationImpl(const IRPosition &IRP, Attributor &A)
STATS_DECLTRACK_CSARG_ATTR(value_range)
}
};
+} // namespace
const char AAReturnedValues::ID = 0;
const char AANoUnwind::ID = 0;
} // namespace llvm
// Overloaded wrappers to go with the function template below.
-BasicBlock *unwrapBlock(BasicBlock *B) { return B; }
-BasicBlock *unwrapBlock(LoopBodyTraits::NodeRef &N) { return N.second; }
+static BasicBlock *unwrapBlock(BasicBlock *B) { return B; }
+static BasicBlock *unwrapBlock(LoopBodyTraits::NodeRef &N) { return N.second; }
static void createNaturalLoop(LoopInfo &LI, DominatorTree &DT, Function *F,
SetVector<BasicBlock *> &Blocks,
parser.getCurrentLocation(), result.operands);
}
+namespace {
template <typename GenericOpType>
struct BlockArgsVerifier {
static LogicalResult verify(GenericOpType op, Block &block);
};
+} // namespace
template <typename GenericOpType>
LogicalResult BlockArgsVerifier<GenericOpType>::verify(GenericOpType op,
// Common verifier for reshape-like types. Fills `expandedType` and
// `collapsedType` with the proper `src` or `result` type.
template <typename Op, typename T>
-LogicalResult verifyReshapeLikeTypes(Op op, T &expandedType, T &collapsedType) {
+static LogicalResult verifyReshapeLikeTypes(Op op, T &expandedType,
+ T &collapsedType) {
expandedType = op.getSrcType();
collapsedType = op.getResultType();
unsigned expandedRank = expandedType.getRank();