WIP: Add support for types to LLVM graphs.

Signed-off-by: format 2020.06.15 <github.com/ChrisCummins/format>

Author: ChrisCummins

programl/graph/format/graphviz_converter.cc

@@ -195,26 +195,29 @@ labm8::Status SerializeGraphVizToString(const ProgramGraph& graph,
 
     // Set the node shape.
     switch (node.type()) {
+      attributes["style"] = "filled";
       case Node::INSTRUCTION:
         attributes["shape"] = "box";
-        attributes["style"] = "filled";
         attributes["fillcolor"] = "#3c78d8";
         attributes["fontcolor"] = "#ffffff";
         break;
       case Node::VARIABLE:
         attributes["shape"] = "ellipse";
-        attributes["style"] = "filled";
         attributes["fillcolor"] = "#f4cccc";
         attributes["color"] = "#990000";
         attributes["fontcolor"] = "#990000";
         break;
       case Node::CONSTANT:
-        attributes["shape"] = "diamond";
-        attributes["style"] = "filled";
+        attributes["shape"] = "octagon";
         attributes["fillcolor"] = "#e99c9c";
         attributes["color"] = "#990000";
         attributes["fontcolor"] = "#990000";
         break;
+      case Node::TYPE:
+        attributes["shape"] = "diamond";
+        attributes["fillcolor"] = "#cccccc";
+        attributes["color"] = "#cccccc";
+        attributes["fontcolor"] = "#222222";
     }
   }
 
@@ -240,8 +243,11 @@ labm8::Status SerializeGraphVizToString(const ProgramGraph& graph,
         break;
       case Edge::CALL:
         attributes["color"] = "#65ae4d";
-        attributes["weight"] = "1";
+        attributes["weight"] = "1";  // TODO: Consider 0
         break;
+      case Edge::TYPE:
+        attributes["color"] = "#aaaaaa";
+        attributes["weight"] = "0";
     }
 
     // Set the edge label.

programl/graph/program_graph_builder.cc

@@ -67,6 +67,10 @@ Node* ProgramGraphBuilder::AddConstant(const string& text) {
   return AddNode(Node::CONSTANT, text);
 }
 
+Node* ProgramGraphBuilder::AddType(const string& text) {
+  return AddNode(Node::TYPE, text);
+}
+
 labm8::StatusOr<Edge*> ProgramGraphBuilder::AddControlEdge(int32_t position,
                                                            const Node* source,
                                                            const Node* target) {
@@ -143,6 +147,28 @@ labm8::StatusOr<Edge*> ProgramGraphBuilder::AddCallEdge(const Node* source,
   return AddEdge(Edge::CALL, /*position=*/0, source, target);
 }
 
+labm8::StatusOr<Edge*> ProgramGraphBuilder::AddTypeEdge(int32_t position,
+                                                        const Node* source,
+                                                        const Node* target) {
+  DCHECK(source) << "nullptr argument";
+  DCHECK(target) << "nullptr argument";
+  DCHECK(source) << "nullptr argument";
+  DCHECK(target) << "nullptr argument";
+
+  if (source->type() != Node::TYPE) {
+    return Status(labm8::error::Code::INVALID_ARGUMENT,
+                  "Invalid source type ({}) for type edge. Expected type",
+                  Node::Type_Name(source->type()));
+  }
+  if (target->type() == Node::INSTRUCTION) {
+    return Status(labm8::error::Code::INVALID_ARGUMENT,
+                  "Invalid destination type (instruction) for type edge. "
+                  "Expected {variable,constant,type}");
+  }
+
+  return AddEdge(Edge::TYPE, position, source, target);
+}
+
 labm8::StatusOr<ProgramGraph> ProgramGraphBuilder::Build() {
   // Check that all nodes except the root are connected. The root is allowed to
   // have no connections in the case where it is an empty graph.

programl/graph/program_graph_builder.h

@@ -61,6 +61,8 @@ class ProgramGraphBuilder {
 
   Node* AddConstant(const string& text);
 
+  Node* AddType(const string& text);
+
   // Edge factories.
   [[nodiscard]] labm8::StatusOr<Edge*> AddControlEdge(int32_t position,
                                                       const Node* source,
@@ -70,7 +72,8 @@ class ProgramGraphBuilder {
                                                    const Node* source,
                                                    const Node* target);
 
-  [[nodiscard]] labm8::StatusOr<Edge*> AddCallEdge(const Node* source,
+  [[nodiscard]] labm8::StatusOr<Edge*> AddCallEdge(int32_t position,
+                                                   const Node* source,
                                                    const Node* target);
 
   const Node* GetRootNode() const { return &graph_.node(0); }
@@ -110,7 +113,7 @@ class ProgramGraphBuilder {
   int32_t GetIndex(const Function* function);
   int32_t GetIndex(const Node* node);
 
-  // Maps which covert store the index of objects in repeated field lists.
+  // Maps which store the index of objects in repeated field lists.
   absl::flat_hash_map<Module*, int32_t> moduleIndices_;
   absl::flat_hash_map<Function*, int32_t> functionIndices_;
   absl::flat_hash_map<Node*, int32_t> nodeIndices_;

programl/ir/llvm/internal/BUILD

@@ -48,6 +48,16 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "program_graph_builder_test",
+    srcs = ["program_graph_builder_test.cc"],
+    deps = [
+        ":program_graph_builder",
+        "//programl/proto:program_graph_options_cc",
+        "@llvm//10.0.0",
+    ],
+)
+
 cc_library(
     name = "program_graph_builder_pass",
     srcs = ["program_graph_builder_pass.cc"],

programl/ir/llvm/internal/program_graph_builder.cc

@@ -31,6 +31,7 @@
 #include "programl/graph/features.h"
 #include "programl/ir/llvm/internal/text_encoder.h"
 #include "programl/proto/program_graph.pb.h"
+#include "program_graph_builder.h"
 
 using labm8::Status;
 
@@ -39,6 +40,11 @@ namespace ir {
 namespace llvm {
 namespace internal {
 
+template<typename T>
+void AddFullTextFeature(T* element, const std::string& fullText) {
+  graph::AddScalarFeature(element, "full_text", fullText);
+}
+
 labm8::StatusOr<BasicBlockEntryExit> ProgramGraphBuilder::VisitBasicBlock(
     const ::llvm::BasicBlock& block, const Function* functionMessage,
     InstructionMap* instructions, ArgumentConsumerMap* argumentConsumers,
@@ -194,7 +200,7 @@ labm8::StatusOr<FunctionEntryExits> ProgramGraphBuilder::VisitFunction(
 
   if (function.isDeclaration()) {
     Node* node = AddInstruction("; undefined function", functionMessage);
-    graph::AddScalarFeature(node, "full_text", "");
+    AddFullTextFeature(node, "");
     functionEntryExits.first = node;
     functionEntryExits.second.push_back(node);
     return functionEntryExits;
@@ -325,7 +331,7 @@ Node* ProgramGraphBuilder::AddLlvmInstruction(
   const LlvmTextComponents text = textEncoder_.Encode(instruction);
   Node* node = AddInstruction(text.opcode_name, function);
   node->set_block(blockCount_);
-  graph::AddScalarFeature(node, "full_text", text.text);
+  AddFullTextFeature(node, text.text);
 
   // Add profiling information features, if available.
   uint64_t profTotalWeight;
@@ -345,29 +351,88 @@ Node* ProgramGraphBuilder::AddLlvmInstruction(
 Node* ProgramGraphBuilder::AddLlvmVariable(const ::llvm::Instruction* operand,
                                            const programl::Function* function) {
   const LlvmTextComponents text = textEncoder_.Encode(operand);
-  Node* node = AddVariable(text.lhs_type, function);
+  Node* node = AddVariable("var", function);
   node->set_block(blockCount_);
-  graph::AddScalarFeature(node, "full_text", text.lhs);
-
+  AddFullTextFeature(node, text.lhs);
   return node;
 }
 
 Node* ProgramGraphBuilder::AddLlvmVariable(const ::llvm::Argument* argument,
                                            const programl::Function* function) {
   const LlvmTextComponents text = textEncoder_.Encode(argument);
-  Node* node = AddVariable(text.lhs_type, function);
+  Node* node = AddVariable("var", function);
   node->set_block(blockCount_);
-  graph::AddScalarFeature(node, "full_text", text.lhs);
+  AddFullTextFeature(node, text.lhs);
+
+  Node* type = GetOrCreateType(operand->getType());
+  AddTypeEdge(/*position=*/0, type, node);
 
   return node;
 }
 
 Node* ProgramGraphBuilder::AddLlvmConstant(const ::llvm::Constant* constant) {
   const LlvmTextComponents text = textEncoder_.Encode(constant);
-  Node* node = AddConstant(text.lhs_type);
+  Node* node = AddConstant("const");
   node->set_block(blockCount_);
-  graph::AddScalarFeature(node, "full_text", text.text);
+  AddFullTextFeature(node, text.text);
 
+  Node* type = GetOrCreateType(operand->getType());
+  AddTypeEdge(/*position=*/0, type, node);
+  return node;
+}
+
+Node* ProgramGraphBuilder::AddLlvmType(const ::llvm::Type* type) {
+  const LlvmTextComponents text = textEncoder_.Encode(constant);
+  Node* node = AddType(text.ls_type);
+  AddFullTextFeature(node, text.lhs);
+  return node;
+}
+
+Node* ProgramGraphBuilder::AddLlvmType(const ::llvm::StructType* type) {
+  Node* node = AddType("struct");
+  AddFullTextFeature(node, type->hasName() ? type->getName() : "struct");
+
+  // Add types for the struct elements, and type edges.
+  for (int i = 0; i < type->getNumElements(); ++i) {
+    const auto& member = type->elements()[i];
+    // Re-use the type if it already exists to prevent duplication of member types.
+    auto memberNode = GetOrCreateType(member);
+    AddTypeEdge(/*position=*/i, memberNode, node);
+  }
+
+  return node;
+}
+
+Node* ProgramGraphBuilder::AddLlvmType(const ::llvm::PointerType* type) {
+  Node* node = AddType("*");
+  AddFullTextFeature(node, textEncoder_.Encode(constant).lhs);
+  // Re-use the type if it already exists to prevent duplication of element types.
+  auto elementType = GetOrCreateType(type->getElementType());
+  AddTypeEdge(/*position=*/0,, elementType, node);
+  return node;
+}
+
+Node* ProgramGraphBuilder::AddLlvmType(const ::llvm::FunctionType* type) {
+  Node* node = AddType("fn");
+  AddFullTextFeature(node, textEncoder_.Encode(constant).lhs);
+  return node;
+}
+
+Node* ProgramGraphBuilder::AddLlvmType(const ::llvm::ArrayType* type) {
+  Node* node = AddType("[]");
+  AddFullTextFeature(node, textEncoder_.Encode(constant).lhs);
+  // Re-use the type if it already exists to prevent duplication of element types.
+  auto elementType = GetOrCreateType(type->getElementType());
+  AddTypeEdge(/*position=*/0, elementType, node);
+  return node;
+}
+
+Node* ProgramGraphBuilder::AddLlvmType(const ::llvm::VectorType* type) {
+  Node* node = AddType("vector");
+  AddFullTextFeature(node, textEncoder_.Encode(constant).lhs);
+  // Re-use the type if it already exists to prevent duplication of element types.
+  auto elementType = GetOrCreateType(type->getElementType());
+  AddTypeEdge(/*position=*/0, elementType, node);
   return node;
 }
 
@@ -465,6 +530,16 @@ void ProgramGraphBuilder::Clear() {
   programl::graph::ProgramGraphBuilder::Clear();
 }
 
+Node* ProgramGraphBuilder::GetOrCreateType(const ::llvm::Type* type) {
+  auto it = types_.find(type);
+  if (it == types_.end()) {
+    Node* node = AddLlvmType(type);
+    types_[type] = node;
+    return node;
+  }
+  return it->second;
+}
+
 }  // namespace internal
 }  // namespace llvm
 }  // namespace ir

programl/ir/llvm/internal/program_graph_builder.h

@@ -26,6 +26,7 @@
 #include "labm8/cpp/string.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "programl/graph/program_graph_builder.h"
@@ -74,6 +75,10 @@ class ProgramGraphBuilder : public programl::graph::ProgramGraphBuilder {
 
   void Clear();
 
+  // Return the node representing a type. If no node already exists for this type, a new node is
+  // created and added to the graph.
+  Node* GetOrCreateType(const ::llvm::Type* type);
+
  protected:
   [[nodiscard]] labm8::StatusOr<FunctionEntryExits> VisitFunction(
       const ::llvm::Function& function, const Function* functionMessage);
@@ -93,6 +98,14 @@ class ProgramGraphBuilder : public programl::graph::ProgramGraphBuilder {
   Node* AddLlvmVariable(const ::llvm::Argument* argument,
                         const Function* function);
   Node* AddLlvmConstant(const ::llvm::Constant* constant);
+  Node* AddLlvmType(const ::llvm::Type* type);
+
+  Node* AddLlvmType(const ::llvm::StructType* type);
+  Node* AddLlvmType(const ::llvm::PointerType* type);
+  // TODO: Node* AddLlvmType(const ::llvm::IntegerType* type);
+  Node* AddLlvmType(const ::llvm::FunctionType* type);
+  Node* AddLlvmType(const ::llvm::ArrayType* type);
+  Node* AddLlvmType(const ::llvm::VectorType* type);
 
  private:
   const ProgramGraphOptions options_;
@@ -110,6 +123,8 @@ class ProgramGraphBuilder : public programl::graph::ProgramGraphBuilder {
   // visited.
   absl::flat_hash_map<const ::llvm::Constant*, std::vector<PositionalNode>>
       constants_;
+  // A map from an LLVM type to the node message that represents it.
+  absl::flat_hash_map<const ::llvm::Type*, Node*> types_;
 };
 
 }  // namespace internal