// This notes that we should ignore those.
static bool hasUsefulEdges(Instruction *);
+const StratifiedIndex StratifiedLink::SetSentinel =
+ std::numeric_limits<StratifiedIndex>::max();
+
namespace {
// StratifiedInfo Attribute things.
typedef unsigned StratifiedAttr;
StratifiedSets<Value *> Sets;
// Lots of functions have < 4 returns. Adjust as necessary.
SmallVector<Value *, 4> ReturnedValues;
+
+ FunctionInfo(StratifiedSets<Value *> &&S,
+ SmallVector<Value *, 4> &&RV)
+ : Sets(std::move(S)), ReturnedValues(std::move(RV)) {}
};
struct CFLAliasAnalysis;
tryInterproceduralAnalysis(const SmallVectorImpl<Function *> &Fns,
Value *FuncValue,
const iterator_range<User::op_iterator> &Args) {
- LLVM_CONSTEXPR unsigned ExpectedMaxArgs = 8;
- LLVM_CONSTEXPR unsigned MaxSupportedArgs = 50;
+ const unsigned ExpectedMaxArgs = 8;
+ const unsigned MaxSupportedArgs = 50;
assert(Fns.size() > 0);
// I put this here to give us an upper bound on time taken by IPA. Is it
// really (realistically) needed? Keep in mind that we do have an n^2 algo.
- if (std::distance(Args.begin(), Args.end()) > MaxSupportedArgs)
+ if (std::distance(Args.begin(), Args.end()) > (int) MaxSupportedArgs)
return false;
// Exit early if we'll fail anyway
}
}
if (AddEdge)
- Output.push_back({FuncValue, ArgVal, EdgeType::Assign,
- StratifiedAttrs().flip()});
+ Output.push_back(Edge(FuncValue, ArgVal, EdgeType::Assign,
+ StratifiedAttrs().flip()));
}
if (Parameters.size() != Arguments.size())
typedef std::size_t Node;
private:
- LLVM_CONSTEXPR static Node StartNode = Node(0);
+ const static Node StartNode = Node(0);
struct Edge {
EdgeTypeT Weight;
Node Other;
+ Edge(const EdgeTypeT &W, const Node &N)
+ : Weight(W), Other(N) {}
+
bool operator==(const Edge &E) const {
return Weight == E.Weight && Other == E.Other;
}
// ----- Actual graph-related things ----- //
- WeightedBidirectionalGraph() = default;
+ WeightedBidirectionalGraph() {}
WeightedBidirectionalGraph(WeightedBidirectionalGraph<EdgeTypeT> &&Other)
: NodeImpls(std::move(Other.NodeImpls)) {}
assert(inbounds(To));
auto &FromNode = getNode(From);
auto &ToNode = getNode(To);
- FromNode.Edges.push_back(Edge{Weight, To});
- ToNode.Edges.push_back(Edge{ReverseWeight, From});
+ FromNode.Edges.push_back(Edge(Weight, To));
+ ToNode.Edges.push_back(Edge(ReverseWeight, From));
}
EdgeIterable edgesFor(const Node &N) const {
auto From = findOrInsertNode(E.From);
auto FlippedWeight = flipWeight(E.Weight);
auto Attrs = E.AdditionalAttrs;
- Graph.addEdge(From, To, {E.Weight, Attrs}, {FlippedWeight, Attrs});
+ Graph.addEdge(From, To, std::make_pair(E.Weight, Attrs),
+ std::make_pair(FlippedWeight, Attrs));
}
}
}
Builder.add(&Arg);
}
- return {Builder.build(), std::move(ReturnedValues)};
+ return FunctionInfo(Builder.build(), std::move(ReturnedValues));
}
void CFLAliasAnalysis::scan(Function *Fn) {