Static Value-Flow Analysis
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | List of all members
SVF::DOTGraphTraits< VFG * > Struct Reference
Inheritance diagram for SVF::DOTGraphTraits< VFG * >:
SVF::DOTGraphTraits< SVFIR * > SVF::DefaultDOTGraphTraits

Public Types

typedef VFGNode NodeType
 

Public Member Functions

 DOTGraphTraits (bool isSimple=false)
 
std::string getNodeLabel (NodeType *node, VFG *graph)
 
- Public Member Functions inherited from SVF::DOTGraphTraits< SVFIR * >
 DOTGraphTraits (bool simple=false)
 
- Public Member Functions inherited from SVF::DefaultDOTGraphTraits
 DefaultDOTGraphTraits (bool simple=false)
 
template<typename GraphType >
std::string getNodeLabel (const void *, const GraphType &)
 

Static Public Member Functions

static std::string getGraphName (VFG *)
 Return name of the graph.
 
static std::string getSimpleNodeLabel (NodeType *node, VFG *)
 Return label of a VFG node without MemSSA information.
 
static std::string getCompleteNodeLabel (NodeType *node, VFG *)
 Return label of a VFG node with MemSSA information.
 
static std::string getNodeAttributes (NodeType *node, VFG *)
 
template<class EdgeIter >
static std::string getEdgeAttributes (NodeType *, EdgeIter EI, VFG *)
 
template<class EdgeIter >
static std::string getEdgeSourceLabel (NodeType *, EdgeIter EI)
 
- Static Public Member Functions inherited from SVF::DefaultDOTGraphTraits
template<typename GraphType >
static std::string getGraphName (const GraphType &)
 
template<typename GraphType >
static std::string getGraphProperties (const GraphType &)
 
static bool renderGraphFromBottomUp ()
 
template<typename GraphType >
static bool isNodeHidden (const void *, const GraphType &)
 
template<typename GraphType >
static std::string getNodeIdentifierLabel (const void *, const GraphType &)
 
template<typename GraphType >
static std::string getNodeDescription (const void *, const GraphType &)
 
template<typename GraphType >
static std::string getNodeAttributes (const void *, const GraphType &)
 
template<typename EdgeIter , typename GraphType >
static std::string getEdgeAttributes (const void *, EdgeIter, const GraphType &)
 
template<typename EdgeIter >
static std::string getEdgeSourceLabel (const void *, EdgeIter)
 
template<typename EdgeIter >
static bool edgeTargetsEdgeSource (const void *, EdgeIter)
 
template<typename EdgeIter >
static EdgeIter getEdgeTarget (const void *, EdgeIter I)
 
static bool hasEdgeDestLabels ()
 
static unsigned numEdgeDestLabels (const void *)
 
static std::string getEdgeDestLabel (const void *, unsigned)
 
template<typename GraphType , typename GraphWriter >
static void addCustomGraphFeatures (const GraphType &, GraphWriter &)
 

Additional Inherited Members

- Protected Member Functions inherited from SVF::DefaultDOTGraphTraits
bool isSimple ()
 

Detailed Description

Definition at line 1091 of file VFG.cpp.

Member Typedef Documentation

◆ NodeType

typedef VFGNode SVF::DOTGraphTraits< VFG * >::NodeType

Definition at line 1094 of file VFG.cpp.

Constructor & Destructor Documentation

◆ DOTGraphTraits()

SVF::DOTGraphTraits< VFG * >::DOTGraphTraits ( bool  isSimple = false)
inline

Definition at line 1095 of file VFG.cpp.

1095 :
1096 DOTGraphTraits<SVFIR*>(isSimple)
1097 {
1098 }
SVF::IRBuilder
llvm::IRBuilder IRBuilder
Definition BasicTypes.h:74

Member Function Documentation

◆ getCompleteNodeLabel()

static std::string SVF::DOTGraphTraits< VFG * >::getCompleteNodeLabel ( NodeType *  node,
VFG *   
)
inlinestatic

Return label of a VFG node with MemSSA information.

Definition at line 1170 of file VFG.cpp.

1171 {
1172
1173 std::string str;
1174 std::stringstream rawstr(str);
1175 if(StmtVFGNode* stmtNode = SVFUtil::dyn_cast<StmtVFGNode>(node))
1176 {
1177 rawstr << stmtNode->toString();
1178 }
1179 else if(BinaryOPVFGNode* bop = SVFUtil::dyn_cast<BinaryOPVFGNode>(node))
1180 {
1181 rawstr << bop->toString();
1182 }
1183 else if(UnaryOPVFGNode* uop = SVFUtil::dyn_cast<UnaryOPVFGNode>(node))
1184 {
1185 rawstr << uop->toString();
1186 }
1187 else if(CmpVFGNode* cmp = SVFUtil::dyn_cast<CmpVFGNode>(node))
1188 {
1189 rawstr << cmp->toString();
1190 }
1191 else if(PHIVFGNode* phi = SVFUtil::dyn_cast<PHIVFGNode>(node))
1192 {
1193 rawstr << phi->toString();
1194 }
1195 else if(FormalParmVFGNode* fp = SVFUtil::dyn_cast<FormalParmVFGNode>(node))
1196 {
1197 rawstr << fp->toString();
1198 }
1199 else if(ActualParmVFGNode* ap = SVFUtil::dyn_cast<ActualParmVFGNode>(node))
1200 {
1201 rawstr << ap->toString();
1202 }
1203 else if(NullPtrVFGNode* nptr = SVFUtil::dyn_cast<NullPtrVFGNode>(node))
1204 {
1205 rawstr << nptr->toString();
1206 }
1207 else if (ActualRetVFGNode* ar = SVFUtil::dyn_cast<ActualRetVFGNode>(node))
1208 {
1209 rawstr << ar->toString();
1210 }
1211 else if (FormalRetVFGNode* fr = SVFUtil::dyn_cast<FormalRetVFGNode>(node))
1212 {
1213 rawstr << fr->toString();
1214 }
1215 else if (MRSVFGNode* mr = SVFUtil::dyn_cast<MRSVFGNode>(node))
1216 {
1217 rawstr << mr->toString();
1218 }
1219 else if (BranchVFGNode* branchNode = SVFUtil::dyn_cast<BranchVFGNode>(node))
1220 {
1221 rawstr << branchNode->toString();
1222 }
1223 else
1224 assert(false && "what else kinds of nodes do we have??");
1225
1226 return rawstr.str();
1227 }

◆ getEdgeAttributes()

template<class EdgeIter >
static std::string SVF::DOTGraphTraits< VFG * >::getEdgeAttributes ( NodeType *  ,
EdgeIter  EI,
VFG *   
)
inlinestatic

Definition at line 1320 of file VFG.cpp.

1321 {
1322 VFGEdge* edge = *(EI.getCurrent());
1323 assert(edge && "No edge found!!");
1324 if (SVFUtil::isa<DirectSVFGEdge>(edge))
1325 {
1326 if (SVFUtil::isa<CallDirSVFGEdge>(edge))
1327 return "style=solid,color=red";
1328 else if (SVFUtil::isa<RetDirSVFGEdge>(edge))
1329 return "style=solid,color=blue";
1330 else
1331 return "style=solid";
1332 }
1333 else if (SVFUtil::isa<IndirectSVFGEdge>(edge))
1334 {
1335 if (SVFUtil::isa<CallIndSVFGEdge>(edge))
1336 return "style=dashed,color=red";
1337 else if (SVFUtil::isa<RetIndSVFGEdge>(edge))
1338 return "style=dashed,color=blue";
1339 else
1340 return "style=dashed";
1341 }
1342 else
1343 {
1344 assert(false && "what else edge we have?");
1345 }
1346 return "";
1347 }

◆ getEdgeSourceLabel()

template<class EdgeIter >
static std::string SVF::DOTGraphTraits< VFG * >::getEdgeSourceLabel ( NodeType *  ,
EdgeIter  EI 
)
inlinestatic

Definition at line 1350 of file VFG.cpp.

1351 {
1352 VFGEdge* edge = *(EI.getCurrent());
1353 assert(edge && "No edge found!!");
1354
1355 std::string str;
1356 std::stringstream rawstr(str);
1357 if (CallDirSVFGEdge* dirCall = SVFUtil::dyn_cast<CallDirSVFGEdge>(edge))
1358 rawstr << dirCall->getCallSiteId();
1359 else if (RetDirSVFGEdge* dirRet = SVFUtil::dyn_cast<RetDirSVFGEdge>(edge))
1360 rawstr << dirRet->getCallSiteId();
1361
1362 return rawstr.str();
1363 }

◆ getGraphName()

static std::string SVF::DOTGraphTraits< VFG * >::getGraphName ( VFG *  )
inlinestatic

Return name of the graph.

Definition at line 1101 of file VFG.cpp.

1102 {
1103 return "VFG";
1104 }

◆ getNodeAttributes()

static std::string SVF::DOTGraphTraits< VFG * >::getNodeAttributes ( NodeType *  node,
VFG *   
)
inlinestatic

Definition at line 1229 of file VFG.cpp.

1230 {
1231 std::string str;
1232 std::stringstream rawstr(str);
1233
1234 if(StmtVFGNode* stmtNode = SVFUtil::dyn_cast<StmtVFGNode>(node))
1235 {
1236 const PAGEdge* edge = stmtNode->getPAGEdge();
1237 if (SVFUtil::isa<AddrStmt>(edge))
1238 {
1239 rawstr << "color=green";
1240 }
1241 else if (SVFUtil::isa<CopyStmt>(edge))
1242 {
1243 rawstr << "color=black";
1244 }
1245 else if (SVFUtil::isa<RetPE>(edge))
1246 {
1247 rawstr << "color=black,style=dotted";
1248 }
1249 else if (SVFUtil::isa<GepStmt>(edge))
1250 {
1251 rawstr << "color=purple";
1252 }
1253 else if (SVFUtil::isa<StoreStmt>(edge))
1254 {
1255 rawstr << "color=blue";
1256 }
1257 else if (SVFUtil::isa<LoadStmt>(edge))
1258 {
1259 rawstr << "color=red";
1260 }
1261 else
1262 {
1263 assert(0 && "No such kind edge!!");
1264 }
1265 rawstr << "";
1266 }
1267 else if (SVFUtil::isa<CmpVFGNode>(node))
1268 {
1269 rawstr << "color=grey";
1270 }
1271 else if (SVFUtil::isa<BinaryOPVFGNode>(node))
1272 {
1273 rawstr << "color=grey";
1274 }
1275 else if (SVFUtil::isa<UnaryOPVFGNode>(node))
1276 {
1277 rawstr << "color=grey";
1278 }
1279 else if(SVFUtil::isa<PHIVFGNode>(node))
1280 {
1281 rawstr << "color=black";
1282 }
1283 else if(SVFUtil::isa<NullPtrVFGNode>(node))
1284 {
1285 rawstr << "color=grey";
1286 }
1287 else if(SVFUtil::isa<FormalParmVFGNode>(node))
1288 {
1289 rawstr << "color=yellow,penwidth=2";
1290 }
1291 else if(SVFUtil::isa<ActualParmVFGNode>(node))
1292 {
1293 rawstr << "color=yellow,penwidth=2";
1294 }
1295 else if (SVFUtil::isa<ActualRetVFGNode>(node))
1296 {
1297 rawstr << "color=yellow,penwidth=2";
1298 }
1299 else if (SVFUtil::isa<FormalRetVFGNode>(node))
1300 {
1301 rawstr << "color=yellow,penwidth=2";
1302 }
1303 else if (SVFUtil::isa<MRSVFGNode>(node))
1304 {
1305 rawstr << "color=orange,penwidth=2";
1306 }
1307 else if (SVFUtil::isa<BranchVFGNode>(node))
1308 {
1309 rawstr << "color=gold,penwidth=2";
1310 }
1311 else
1312 assert(false && "no such kind of node!!");
1313
1314 rawstr << "";
1315
1316 return rawstr.str();
1317 }

◆ getNodeLabel()

std::string SVF::DOTGraphTraits< VFG * >::getNodeLabel ( NodeType *  node,
VFG *  graph 
)
inline

Definition at line 1106 of file VFG.cpp.

1107 {
1108 if (isSimple())
1109 return getSimpleNodeLabel(node, graph);
1110 else
1111 return getCompleteNodeLabel(node, graph);
1112 }
SVF::DOTGraphTraits< VFG * >::getCompleteNodeLabel
static std::string getCompleteNodeLabel(NodeType *node, VFG *)
Return label of a VFG node with MemSSA information.
Definition VFG.cpp:1170
SVF::DOTGraphTraits< VFG * >::getSimpleNodeLabel
static std::string getSimpleNodeLabel(NodeType *node, VFG *)
Return label of a VFG node without MemSSA information.
Definition VFG.cpp:1115

◆ getSimpleNodeLabel()

static std::string SVF::DOTGraphTraits< VFG * >::getSimpleNodeLabel ( NodeType *  node,
VFG *   
)
inlinestatic

Return label of a VFG node without MemSSA information.

Definition at line 1115 of file VFG.cpp.

1116 {
1117 std::string str;
1118 std::stringstream rawstr(str);
1119 if(StmtVFGNode* stmtNode = SVFUtil::dyn_cast<StmtVFGNode>(node))
1120 {
1121 rawstr << stmtNode->toString();
1122 }
1123 else if(PHIVFGNode* tphi = SVFUtil::dyn_cast<PHIVFGNode>(node))
1124 {
1125 rawstr << tphi->toString();
1126 }
1127 else if(FormalParmVFGNode* fp = SVFUtil::dyn_cast<FormalParmVFGNode>(node))
1128 {
1129 rawstr << fp->toString();
1130 }
1131 else if(ActualParmVFGNode* ap = SVFUtil::dyn_cast<ActualParmVFGNode>(node))
1132 {
1133 rawstr << ap->toString();
1134 }
1135 else if (ActualRetVFGNode* ar = SVFUtil::dyn_cast<ActualRetVFGNode>(node))
1136 {
1137 rawstr << ar->toString();
1138 }
1139 else if (FormalRetVFGNode* fr = SVFUtil::dyn_cast<FormalRetVFGNode>(node))
1140 {
1141 rawstr << fr->toString();
1142 }
1143 else if(SVFUtil::isa<NullPtrVFGNode>(node))
1144 {
1145 rawstr << "NullPtr";
1146 }
1147 else if(BinaryOPVFGNode* bop = SVFUtil::dyn_cast<BinaryOPVFGNode>(node))
1148 {
1149 rawstr << bop->toString();
1150 }
1151 else if(UnaryOPVFGNode* uop = SVFUtil::dyn_cast<UnaryOPVFGNode>(node))
1152 {
1153 rawstr << uop->toString();
1154 }
1155 else if(CmpVFGNode* cmp = SVFUtil::dyn_cast<CmpVFGNode>(node))
1156 {
1157 rawstr << cmp->toString();;
1158 }
1159 else if (BranchVFGNode* branchNode = SVFUtil::dyn_cast<BranchVFGNode>(node))
1160 {
1161 rawstr << branchNode->toString();
1162 }
1163 else
1164 assert(false && "what else kinds of nodes do we have??");
1165
1166 return rawstr.str();
1167 }
The documentation for this struct was generated from the following file:
Generated by doxygen 1.9.8