68#define PASS_KEY "x86-lvi-load"
69#define DEBUG_TYPE PASS_KEY
71STATISTIC(NumFences,
"Number of LFENCEs inserted for LVI mitigation");
72STATISTIC(NumFunctionsConsidered,
"Number of functions analyzed");
73STATISTIC(NumFunctionsMitigated,
"Number of functions for which mitigations "
75STATISTIC(NumGadgets,
"Number of LVI gadgets detected during analysis");
83 cl::desc(
"Don't treat conditional branches as disclosure gadgets. This "
84 "may improve performance, at the cost of security."),
90 "For each function, emit a dot graph depicting potential LVI gadgets"),
95 cl::desc(
"For each function, emit a dot graph depicting potential LVI "
96 "gadgets, and do not insert any fences"),
101 cl::desc(
"For each function, emit a dot graph to stdout depicting "
102 "potential LVI gadgets, used for testing purposes only"),
106typedef int (*
OptimizeCutT)(
unsigned int *Nodes,
unsigned int NodesSize,
107 unsigned int *Edges,
int *EdgeValues,
108 int *CutEdges ,
unsigned int EdgesSize);
114 static constexpr int GadgetEdgeSentinel = -1;
115 static constexpr MachineInstr *
const ArgNodeSentinel =
nullptr;
118 using Node =
typename GraphT::Node;
119 using Edge =
typename GraphT::Edge;
121 MachineGadgetGraph(std::unique_ptr<
Node[]> Nodes,
122 std::unique_ptr<Edge[]> Edges, size_type NodesSize,
123 size_type EdgesSize,
int NumFences = 0,
int NumGadgets = 0)
124 : GraphT(std::move(Nodes), std::move(Edges), NodesSize, EdgesSize),
125 NumFences(NumFences), NumGadgets(NumGadgets) {}
126 static inline bool isCFGEdge(
const Edge &E) {
127 return E.getValue() != GadgetEdgeSentinel;
129 static inline bool isGadgetEdge(
const Edge &E) {
130 return E.getValue() == GadgetEdgeSentinel;
141 return "X86 Load Value Injection (LVI) Load Hardening";
150 using Edge = MachineGadgetGraph::Edge;
151 using Node = MachineGadgetGraph::Node;
152 using EdgeSet = MachineGadgetGraph::EdgeSet;
153 using NodeSet = MachineGadgetGraph::NodeSet;
159 std::unique_ptr<MachineGadgetGraph>
164 std::unique_ptr<MachineGadgetGraph> Graph)
const;
166 std::unique_ptr<MachineGadgetGraph> Graph)
const;
167 int elimMitigatedEdgesAndNodes(MachineGadgetGraph &
G,
170 std::unique_ptr<MachineGadgetGraph>
171 trimMitigatedEdges(std::unique_ptr<MachineGadgetGraph> Graph)
const;
173 EdgeSet &CutEdges )
const;
174 bool instrUsesRegToAccessMemory(
const MachineInstr &
I,
unsigned Reg)
const;
175 bool instrUsesRegToBranch(
const MachineInstr &
I,
unsigned Reg)
const;
177 return MI && (
MI->getOpcode() == X86::LFENCE ||
178 (STI->useLVIControlFlowIntegrity() &&
MI->isCall()));
202 if (Node->getValue() == MachineGadgetGraph::ArgNodeSentinel)
207 OS << *Node->getValue();
213 if (
MI == MachineGadgetGraph::ArgNodeSentinel)
214 return "color = blue";
215 if (
MI->getOpcode() == X86::LFENCE)
216 return "color = green";
222 int EdgeVal = (*
E.getCurrent()).getValue();
223 return EdgeVal >= 0 ?
"label = " + std::to_string(EdgeVal)
224 :
"color = red, style = \"dashed\"";
230constexpr MachineInstr *MachineGadgetGraph::ArgNodeSentinel;
231constexpr int MachineGadgetGraph::GadgetEdgeSentinel;
233char X86LoadValueInjectionLoadHardeningPass::ID = 0;
235void X86LoadValueInjectionLoadHardeningPass::getAnalysisUsage(
245 MachineGadgetGraph *
G) {
247 "Speculative gadgets for \"" + MF.
getName() +
"\" function");
250bool X86LoadValueInjectionLoadHardeningPass::runOnMachineFunction(
255 if (!STI->useLVILoadHardening())
264 if (!
F.hasOptNone() && skipFunction(
F))
267 ++NumFunctionsConsidered;
268 TII = STI->getInstrInfo();
269 TRI = STI->getRegisterInfo();
271 const auto &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
272 const auto &MDT = getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
273 const auto &MDF = getAnalysis<MachineDominanceFrontier>();
274 std::unique_ptr<MachineGadgetGraph> Graph = getGadgetGraph(MF, MLI, MDT, MDF);
276 if (Graph ==
nullptr)
287 std::string FileName =
"lvi.";
303 std::string ErrorMsg;
306 if (!ErrorMsg.empty())
313 FencesInserted = hardenLoadsWithPlugin(MF, std::move(Graph));
315 FencesInserted = hardenLoadsWithHeuristic(MF, std::move(Graph));
318 if (FencesInserted > 0)
319 ++NumFunctionsMitigated;
320 NumFences += FencesInserted;
321 return (FencesInserted > 0);
324std::unique_ptr<MachineGadgetGraph>
325X86LoadValueInjectionLoadHardeningPass::getGadgetGraph(
332 DataFlowGraph DFG{MF, *
TII, *
TRI, MDT, MDF};
337 GraphBuilder Builder;
338 using GraphIter =
typename GraphBuilder::BuilderNodeRef;
340 int FenceCount = 0, GadgetCount = 0;
343 if (
Ref == NodeMap.
end()) {
344 auto I = Builder.addVertex(
MI);
346 return std::pair<GraphIter, bool>{
I,
true};
348 return std::pair<GraphIter, bool>{
Ref->getSecond(),
false};
359 auto AnalyzeDef = [&](NodeAddr<DefNode *> SourceDef) {
361 std::function<void(NodeAddr<DefNode *>)> AnalyzeDefUseChain =
362 [&](NodeAddr<DefNode *>
Def) {
368 RegisterRef DefReg =
Def.Addr->getRegRef(DFG);
369 for (
auto UseID :
L.getAllReachedUses(DefReg, Def)) {
370 auto Use = DFG.addr<UseNode *>(UseID);
371 if (
Use.Addr->getFlags() & NodeAttrs::PhiRef) {
372 NodeAddr<PhiNode *>
Phi =
Use.Addr->getOwner(DFG);
373 for (
const auto&
I :
L.getRealUses(
Phi.Id)) {
374 if (DFG.getPRI().alias(RegisterRef(
I.first), DefReg)) {
375 for (
const auto &UA :
I.second)
376 Uses.emplace(UA.first);
387 for (
auto UseID :
Uses) {
388 if (!UsesVisited.
insert(UseID).second)
391 auto Use = DFG.addr<UseNode *>(UseID);
392 assert(!(
Use.Addr->getFlags() & NodeAttrs::PhiRef));
405 if (instrUsesRegToAccessMemory(
UseMI, UseMO.
getReg()) ||
408 Transmitters[
Def.Id].push_back(
Use.Addr->getOwner(DFG).Id);
416 NodeAddr<InstrNode *> Owner{
Use.Addr->getOwner(DFG)};
418 for (
const auto &ChildDef :
419 Owner.Addr->members_if(DataFlowGraph::IsDef, DFG)) {
420 if (!DefsVisited.
insert(ChildDef.Id).second)
422 if (
Def.Addr->getAttrs() & NodeAttrs::Dead)
424 if (
Def.Id == ChildDef.Id)
427 AnalyzeDefUseChain(ChildDef);
430 for (
auto TransmitterId : Transmitters[ChildDef.Id])
431 Transmitters[
Def.Id].push_back(TransmitterId);
437 auto &DefTransmitters = Transmitters[
Def.Id];
442 DefTransmitters.end());
446 AnalyzeDefUseChain(SourceDef);
447 auto &SourceDefTransmitters = Transmitters[SourceDef.Id];
448 if (SourceDefTransmitters.empty())
452 ? MachineGadgetGraph::ArgNodeSentinel
454 auto GadgetSource = MaybeAddNode(Source);
456 for (
auto TransmitterId : SourceDefTransmitters) {
458 auto GadgetSink = MaybeAddNode(Sink);
460 Builder.addEdge(MachineGadgetGraph::GadgetEdgeSentinel,
461 GadgetSource.first, GadgetSink.first);
466 LLVM_DEBUG(
dbgs() <<
"Analyzing def-use chains to find gadgets\n");
468 NodeAddr<BlockNode *> EntryBlock = DFG.getFunc().Addr->getEntryBlock(DFG);
469 for (NodeAddr<PhiNode *> ArgPhi :
470 EntryBlock.Addr->members_if(DataFlowGraph::IsPhi, DFG)) {
471 NodeList Defs = ArgPhi.Addr->members_if(DataFlowGraph::IsDef, DFG);
475 for (NodeAddr<BlockNode *> BA : DFG.getFunc().Addr->members(DFG)) {
476 for (NodeAddr<StmtNode *> SA :
477 BA.Addr->members_if(DataFlowGraph::IsCode<NodeAttrs::Stmt>, DFG)) {
482 }
else if (
MI->mayLoad()) {
483 NodeList Defs = SA.Addr->members_if(DataFlowGraph::IsDef, DFG);
490 if (GadgetCount == 0)
492 NumGadgets += GadgetCount;
502 auto BeginBB = MaybeAddNode(&*NI);
503 Builder.addEdge(ParentDepth, GI, BeginBB.first);
509 while (++NI !=
MBB->
end()) {
511 if (
Ref != NodeMap.
end()) {
512 Builder.addEdge(LoopDepth, GI,
Ref->getSecond());
513 GI =
Ref->getSecond();
520 auto EndBB = MaybeAddNode(&*
T);
522 Builder.addEdge(LoopDepth, GI, EndBB.first);
527 TraverseCFG(Succ, GI, LoopDepth);
531 GraphIter ArgNode = MaybeAddNode(MachineGadgetGraph::ArgNodeSentinel).first;
532 TraverseCFG(&MF.
front(), ArgNode, 0);
533 std::unique_ptr<MachineGadgetGraph>
G{Builder.get(FenceCount, GadgetCount)};
539int X86LoadValueInjectionLoadHardeningPass::elimMitigatedEdgesAndNodes(
540 MachineGadgetGraph &
G, EdgeSet &ElimEdges ,
542 if (
G.NumFences > 0) {
545 for (
const Edge &E :
G.edges()) {
546 const Node *Dest = E.getDest();
547 if (isFence(Dest->getValue())) {
550 for (
const Edge &DE : Dest->edges())
551 ElimEdges.insert(DE);
557 int RemainingGadgets = 0;
559 for (
const Node &RootN :
G.nodes()) {
560 if (
llvm::none_of(RootN.edges(), MachineGadgetGraph::isGadgetEdge))
564 ReachableNodes.clear();
565 std::function<void(
const Node *,
bool)> FindReachableNodes =
566 [&](
const Node *
N,
bool FirstNode) {
568 ReachableNodes.insert(*
N);
569 for (
const Edge &E :
N->edges()) {
570 const Node *Dest = E.getDest();
571 if (MachineGadgetGraph::isCFGEdge(E) && !ElimEdges.contains(E) &&
572 !ReachableNodes.contains(*Dest))
573 FindReachableNodes(Dest,
false);
576 FindReachableNodes(&RootN,
true);
579 for (
const Edge &E : RootN.edges()) {
580 if (MachineGadgetGraph::isGadgetEdge(E)) {
581 if (ReachableNodes.contains(*E.getDest())) {
590 return RemainingGadgets;
593std::unique_ptr<MachineGadgetGraph>
594X86LoadValueInjectionLoadHardeningPass::trimMitigatedEdges(
595 std::unique_ptr<MachineGadgetGraph> Graph)
const {
597 EdgeSet ElimEdges{*Graph};
598 int RemainingGadgets =
599 elimMitigatedEdgesAndNodes(*Graph, ElimEdges, ElimNodes);
600 if (ElimEdges.empty() && ElimNodes.
empty()) {
601 Graph->NumFences = 0;
602 Graph->NumGadgets = RemainingGadgets;
604 Graph = GraphBuilder::trim(*Graph, ElimNodes, ElimEdges, 0 ,
610int X86LoadValueInjectionLoadHardeningPass::hardenLoadsWithPlugin(
611 MachineFunction &MF, std::unique_ptr<MachineGadgetGraph> Graph)
const {
612 int FencesInserted = 0;
616 Graph = trimMitigatedEdges(std::move(Graph));
618 if (Graph->NumGadgets == 0)
622 EdgeSet CutEdges{*Graph};
623 auto Nodes = std::make_unique<unsigned int[]>(Graph->nodes_size() +
625 auto Edges = std::make_unique<unsigned int[]>(Graph->edges_size());
626 auto EdgeCuts = std::make_unique<int[]>(Graph->edges_size());
627 auto EdgeValues = std::make_unique<int[]>(Graph->edges_size());
628 for (
const Node &
N : Graph->nodes()) {
629 Nodes[Graph->getNodeIndex(
N)] = Graph->getEdgeIndex(*
N.edges_begin());
631 Nodes[Graph->nodes_size()] = Graph->edges_size();
632 for (
const Edge &E : Graph->edges()) {
633 Edges[Graph->getEdgeIndex(E)] = Graph->getNodeIndex(*E.getDest());
634 EdgeValues[Graph->getEdgeIndex(E)] = E.getValue();
636 OptimizeCut(Nodes.get(), Graph->nodes_size(), Edges.get(), EdgeValues.get(),
637 EdgeCuts.get(), Graph->edges_size());
638 for (
int I = 0;
I < Graph->edges_size(); ++
I)
645 FencesInserted += insertFences(MF, *Graph, CutEdges);
647 LLVM_DEBUG(
dbgs() <<
"Inserted " << FencesInserted <<
" fences\n");
649 Graph = GraphBuilder::trim(*Graph,
NodeSet{*Graph}, CutEdges);
652 return FencesInserted;
655int X86LoadValueInjectionLoadHardeningPass::hardenLoadsWithHeuristic(
656 MachineFunction &MF, std::unique_ptr<MachineGadgetGraph> Graph)
const {
659 if (Graph->NumFences > 0) {
661 Graph = trimMitigatedEdges(std::move(Graph));
665 if (Graph->NumGadgets == 0)
669 EdgeSet CutEdges{*Graph};
673 for (
const Edge &E : Graph->edges())
674 if (MachineGadgetGraph::isCFGEdge(E))
675 IngressEdgeMap[E.getDest()].push_back(&E);
685 for (
const Node &
N : Graph->nodes()) {
686 for (
const Edge &E :
N.edges()) {
687 if (!MachineGadgetGraph::isGadgetEdge(E))
692 for (
const Edge &EgressEdge :
N.edges())
693 if (MachineGadgetGraph::isCFGEdge(EgressEdge))
696 int EgressCutCost = 0, IngressCutCost = 0;
697 for (
const Edge *EgressEdge : EgressEdges)
698 if (!CutEdges.contains(*EgressEdge))
699 EgressCutCost += EgressEdge->getValue();
700 for (
const Edge *IngressEdge : IngressEdges)
701 if (!CutEdges.contains(*IngressEdge))
702 IngressCutCost += IngressEdge->getValue();
705 IngressCutCost < EgressCutCost ? IngressEdges : EgressEdges;
706 for (
const Edge *E : EdgesToCut)
714 int FencesInserted = insertFences(MF, *Graph, CutEdges);
716 LLVM_DEBUG(
dbgs() <<
"Inserted " << FencesInserted <<
" fences\n");
718 return FencesInserted;
721int X86LoadValueInjectionLoadHardeningPass::insertFences(
723 EdgeSet &CutEdges )
const {
724 int FencesInserted = 0;
725 for (
const Node &
N :
G.nodes()) {
726 for (
const Edge &E :
N.edges()) {
727 if (CutEdges.contains(E)) {
731 if (
MI == MachineGadgetGraph::ArgNodeSentinel) {
736 }
else if (
MI->isBranch()) {
737 MBB =
MI->getParent();
739 Prev =
MI->getPrevNode();
742 for (
const Edge &E :
N.edges()) {
743 if (MachineGadgetGraph::isCFGEdge(E))
747 MBB =
MI->getParent();
748 InsertionPt =
MI->getNextNode() ?
MI->getNextNode() :
MBB->
end();
749 Prev = InsertionPt ==
MBB->
end()
751 : InsertionPt->getPrevNode();
754 if ((InsertionPt ==
MBB->
end() || !isFence(&*InsertionPt)) &&
755 (!Prev || !isFence(Prev))) {
762 return FencesInserted;
765bool X86LoadValueInjectionLoadHardeningPass::instrUsesRegToAccessMemory(
767 if (!
MI.mayLoadOrStore() ||
MI.getOpcode() == X86::MFENCE ||
768 MI.getOpcode() == X86::SFENCE ||
MI.getOpcode() == X86::LFENCE)
772 if (MemRefBeginIdx < 0) {
773 LLVM_DEBUG(
dbgs() <<
"Warning: unable to obtain memory operand for loading "
783 return (BaseMO.
isReg() && BaseMO.
getReg() != X86::NoRegister &&
784 TRI->regsOverlap(BaseMO.
getReg(), Reg)) ||
785 (IndexMO.
isReg() && IndexMO.
getReg() != X86::NoRegister &&
786 TRI->regsOverlap(IndexMO.
getReg(), Reg));
789bool X86LoadValueInjectionLoadHardeningPass::instrUsesRegToBranch(
791 if (!
MI.isConditionalBranch())
794 if (
Use.isReg() &&
Use.getReg() == Reg)
800 "X86 LVI load hardening",
false,
false)
808 return new X86LoadValueInjectionLoadHardeningPass();
MachineInstrBuilder & UseMI
AMDGPU Mark last scratch load
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file defines the DenseMap class.
const HexagonInstrInfo * TII
Description: ImmutableGraph is a fast DAG implementation that cannot be modified, except by creating ...
unsigned const TargetRegisterInfo * TRI
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Remove Loads Into Fake Uses
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallSet class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
int(* OptimizeCutT)(unsigned int *Nodes, unsigned int NodesSize, unsigned int *Edges, int *EdgeValues, int *CutEdges, unsigned int EdgesSize)
static cl::opt< bool > EmitDot(PASS_KEY "-dot", cl::desc("For each function, emit a dot graph depicting potential LVI gadgets"), cl::init(false), cl::Hidden)
static cl::opt< std::string > OptimizePluginPath(PASS_KEY "-opt-plugin", cl::desc("Specify a plugin to optimize LFENCE insertion"), cl::Hidden)
static void writeGadgetGraph(raw_ostream &OS, MachineFunction &MF, MachineGadgetGraph *G)
static cl::opt< bool > EmitDotVerify(PASS_KEY "-dot-verify", cl::desc("For each function, emit a dot graph to stdout depicting " "potential LVI gadgets, used for testing purposes only"), cl::init(false), cl::Hidden)
static llvm::sys::DynamicLibrary OptimizeDL
static OptimizeCutT OptimizeCut
static cl::opt< bool > EmitDotOnly(PASS_KEY "-dot-only", cl::desc("For each function, emit a dot graph depicting potential LVI " "gadgets, and do not insert any fences"), cl::init(false), cl::Hidden)
static cl::opt< bool > NoConditionalBranches(PASS_KEY "-no-cbranch", cl::desc("Don't treat conditional branches as disclosure gadgets. This " "may improve performance, at the cost of security."), cl::init(false), cl::Hidden)
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesCFG()
This function should be called by the pass, iff they do not:
iterator find(const_arg_type_t< KeyT > Val)
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
virtual std::string message() const
Return the error message as a string.
This class wraps a filename and another Error.
FunctionPass class - This class is used to implement most global optimizations.
unsigned getLoopDepth(const BlockT *BB) const
Return the loop nesting level of the specified block.
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
iterator_range< succ_iterator > successors()
Analysis pass which computes a MachineDominatorTree.
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
const MachineBasicBlock & front() const
Representation of each machine instruction.
const MachineBasicBlock * getParent() const
MachineOperand class - Representation of each machine instruction operand.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
Register getReg() const
getReg - Returns the register number.
A NodeSet contains a set of SUnit DAG nodes with additional information that assigns a priority to th...
virtual void print(raw_ostream &OS, const Module *M) const
print - Print out the internal state of the pass.
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
TargetInstrInfo - Interface to description of machine instruction set.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
A Use represents the edge between a Value definition and its users.
A raw_ostream that writes to a file descriptor.
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
This class provides a portable interface to dynamic libraries which also might be known as shared lib...
static DynamicLibrary getPermanentLibrary(const char *filename, std::string *errMsg=nullptr)
This function permanently loads the dynamic library at the given path using the library load operatio...
void * getAddressOfSymbol(const char *symbolName)
Searches through the library for the symbol symbolName.
bool isValid() const
Returns true if the object refers to a valid library.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
int getFirstAddrOperandIdx(const MachineInstr &MI)
Return the index of the instruction's first address operand, if it has a memory reference,...
initializer< Ty > init(const Ty &Val)
NodeAddr< PhiNode * > Phi
NodeAddr< DefNode * > Def
std::set< NodeId > NodeSet
This is an optimization pass for GlobalISel generic memory operations.
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
FunctionPass * createX86LoadValueInjectionLoadHardeningPass()
raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
raw_ostream & WriteGraph(raw_ostream &O, const GraphType &G, bool ShortNames=false, const Twine &Title="")
auto unique(Range &&R, Predicate P)
void sort(IteratorTy Start, IteratorTy End)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Ref
The access may reference the value stored in memory.
typename Traits::NodeRef NodeRef
static std::string getNodeAttributes(NodeRef Node, GraphType *)
typename Traits::ChildIteratorType ChildIteratorType
std::string getNodeLabel(NodeRef Node, GraphType *)
static std::string getEdgeAttributes(NodeRef, ChildIteratorType E, GraphType *)
MachineGadgetGraph GraphType
typename Traits::EdgeRef EdgeRef
typename Traits::ChildEdgeIteratorType ChildEdgeIteratorType
DOTGraphTraits(bool IsSimple=false)
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
typename GraphType::UnknownGraphTypeError NodeRef